Expressions use operators, methods and functions calls to calculate new values using existing values. Although the expression examples on this page use numbers, similar expressions may be formulated that manipulate values of other types.

Arithmetic expressions

Arithmetic Operators

Integer and floating point numbers may be calculated using arithmetic operators:

'+'
Add
'-'
Subtract (or negate when used as a prefix operator)
'*'
Multiply
'/'
Divide
'%'
Modulo (remainder)

Thus:

-12 + 14    // 2
6 / 5       // 1
-4 % 3      // -1 (where -4/3 --> -1, truncating towards zero)
2*2 + 2*3   // 10 (standard algebraic operator precedence)
2 * (4 + 1) // 10 (parentheses override operator precedence)

Arithmetic Assignment

The arithmetic assignment operators (e.g., '+=', '-=', '*=', '/=') offer a convenient way to update an existing stored value:

counter = 3
counter += 1  // 4. Equivalent to: counter = counter + 1

Numeric methods

Additional numeric calculations can be performed using built-in methods. The name of the desired method follows the value, separated by the dot operator ('.'):

(-1).abs    // 1 (the absolute value, making a number positive)
(pi/2).sin  // 1.0 (trigonometric sine function)

Sometimes, a method may require additional values. These argument values are specified within parentheses following the method's name.

4.max(5)    // 5 (returns the larger of the two numbers)

Method use is very common and convenient. It is helpful to know that:

Methods are covered more thoroughly in a later chapter.

Function calls

Function calls are very much like method calls, except they are not applied to a value in the same way. Instead of specifying a value, dot operator, and a method name, one simply specifies the function name followed by any comma-separated arguments in parentheses.

pow(10f, 2f)

Numeric conversions

Numbers are automatically converted whenever copied from one number type to another.

imm six i32 = 6u8    // Converts 8-bit unsigned integer to 32-bit signed integer
imm sixf f64 = six   // Converts 32-bit signed integer to 64-bit floating point number

If the receiving number type is smaller, numeric information may be lost.

The type of a number that results from an arithmetic operation is that of the left-hand number. If necessary, the right hand number is converted prior to the operation.

imm r = 5.0 + 2  // 7.0f32

Logical expressions

The logical operators operate on true/false values:

'|'
Or
'&'
And
'^'
Xor
'~'
Not

For example:

true | (false & true) // true
true ^ ~true          // true

These bitwise operators may also be used on unsigned integers, as they are viewed as a collection of true/false bits.

0xE0u | 0xB8u  // 0xF8u

Shift methods

The shifting of an unsigned integer's bit is accomplished using the shl and shr methods:

0x0Cu.shl(1)    // 0x18, after shifting bits left once

Logical assignment operators

These work in a similar manner to the arithmetic assignment operators:

mut flags = 0xC0u
flags |= 0x01u   // 0xC1u

Other Expression Operators

Cone supports several more expression operators. Descriptions may be found in the chapters relevant to their common use:

_