Identifiers work as you expect, they reference a variable or constant. The
`Super` keyword references the parent type or any member within it.
### Vector literals
Vector literals are not under object literals as they are not constants in the
same manner as other literals, since they contain expressions within them. As
such, they are expressions, not proper value-based literals. They can be formed
with:
```
( X , Y ) //=> vector2, where X is not a vector2
( X , Y ) //=> vector3, where X *is* a vector2
( X , Y , Z ) //=> vector3
```
All components must have type `double`, except in the second grammar where `X`
is `vector2`.
## Postfix expressions
Postfix expressions are affixed at the end of an expression, and are used for a
large variety of things, although the actual amount of postfix expressions is
small:
| Form | Description |
| ---- | ----------- |
| `A ( $[Argument-list]$ )` | Function call. |
| `Type ( A )` | Type cast. |
| `( class < Type > ) ( A )` | Class type reference cast. |
| `A [ B ]` | Array access. |
| `A.B` | Member access. |
| `A++` | Post-increment. This increments (adds 1 to) the object after the expression is evaluated. |
| `A--` | Post-decrement. This decrements (subtracts 1 from) the object after the expression is evaluated. |
### Argument list
The syntax for an argument list is:
```
Expression $[ , Expression]$...
```
Function calls may name arguments which have defaults with the syntax
`Identifier : Expression`, possibly skipping over other defaulted arguments.
After the first named defaultable argument, all other arguments must be named
as well.
## Unary expressions
Unary expressions are affixed at the beginning of an expression. The simplest
example of a unary expression is the negation operator, `-`, as in `-500`.
Unary expressions include:
| Form | Description |
| ---- | ----------- |
| `- A` | Negation. |
| `! A` | Logical negation, "not." |
| `++ A` | Pre-increment. This adds 1 to the object and evaluates as the resulting value. |
| `-- A` | Pre-decrement. This subtracts 1 from the object and evaluates as the resulting value. |
| `~ A` | Bitwise negation. Flips all bits in an integer. |
| `+ A` | Affirmation. Does not actually do anything. |
| `alignof A` | Evaluates the alignment of the type of an expression. Unknown purpose. |
| `sizeof A` | Evaluates the size of the type of an expression. Unknown purpose. |
## Binary expressions
Binary expressions operate on two expressions, and are the most common kind of
expression. They are used inline like regular math syntax, i.e. `1 + 1`. Binary
expressions include:
| Form | Description |
| ---- | ----------- |
| `A + B` | Addition. |
| `A - B` | Subtraction. |
| `A * B` | Multiplication. |
| `A / B` | Division quotient. |
| `A % B` | Division remainder, also known as "modulus." Unlike C, this works on floats, too. |
| `A ** B` | Exponent ("power of.") |
| `A << B` | Left bitwise shift. |
| `A >> B` | Right bitwise shift. |
| `A >>> B` | Right unsigned bitwise shift. |
| `A cross B` | Vector cross-product. |
| `A dot B` | Vector dot-product. |
| `A .. B` | Concatenation, creates a string from two values. |
| `A < B` | `true` if `A` is less than `B`. |
| `A > B` | `true` if `A` is greater than `B`. |
| `A <= B` | `true` if `A` is less than or equal to `B`. |
| `A >= B` | `true` if `A` is greater than or equal to `B`. |
| `A == B` | `true` if `A` is equal to `B`. |
| `A != B` | `true` if `A` is not equal to `B`. |
| `A ~== B` | `true` if `A` is approximately equal to `B`. For strings this is a case-insensitive comparison, for floats and vectors this checks if the difference between the two is smaller than ε. |
| `A && B` | `true` if `A` and `B` are both `true`. |
| `A \|\| B` | `true` if `A` or `B` is `true`. |
| `A is "B"` | `true` if `A`'s type is equal to or a descendant of `B`. |
| `A <>= B` | Signed difference between `A` and `B`. |