The "Unknown:"s below indicate that an entry is incomplete.
| { ... }(1) | block (grouping statements, especially when statements are not expressions) |
| \ | breaking lines (useful when end-of-line and/or indentation has a special meaning) |
| # | commenting (until end of line) |
| < > <= >= | comparison |
| min / max | comparison (min / max (binary or more)) |
| compareTo | comparison (returns 4 values (i.e. inferior, equal, superior or not comparable)) |
| /** ... */(2) | documentation comment (non nestable) |
| == != | equality / inequality (deep) |
| interp.gc() | force garbage collection |
| ( ... ) | grouping expressions |
| case-sensitive: identifiers case-insensitive: keywords | tokens (case-sensitivity (keywords, variable identifiers...)) |
| [_a-zA-Z][_a-zA-Z0-9]* | tokens (variable identifier regexp) |
| CamelCase or camelCase | tokens (what is the standard way for scrunching together multiple words) |
| := | variable assignment or declaration (assignment) |
| def v := e / var v := e | variable assignment or declaration (declaration) |
Unknown:
information about the current line and file
comparison (returns 3 values (i.e. inferior, equal or superior))
runtime evaluation
| def _(para1, para2, ...) ... { ... } | anonymous function |
| f(a,b,...) | function call |
| f() | function call (with no parameter) |
| match [name, args] { ... } | function called when a function is not defined (in dynamic languages) |
| def f(para1, para2, ...) ... { ... } | function definition |
| return(3) | function return value (breaks the control flow) |
| continue / break | breaking control flow (continue / break) |
| return(3) | breaking control flow (returning a value) |
| throw | exception (throwing) |
| if (c) {...} | if_then |
| if (c) {b1} else {b2} | if_then_else |
| while (c) ... | loop (while condition do something) |
switch (val) {
match v1 { ... }
match v2 { ... }
match _ { ... }
} | multiple selection (switch) |
| ; | sequence |
| end-of-line | sequence |
Unknown:
loop (do something until condition)
loop (for each value in a numeric range, 1 increment (see also the entries about ranges))
loop (for each value in a numeric range, 1 decrement)
loop (for each value in a numeric range, free increment)
loop (for "a la C" (while + initialisation))
exception (catching)
| : | annotation (or variable declaration) |
| e : t | cast (computed conversion (calls an internal or a user-defined function)) |
| e : t | cast (downcast (need runtime checking)) |
| super | accessing parent method |
| object_name if defined as: def object_name { ... } | current instance |
| getAllegedType | get the type/class corresponding to an object/instance/value |
| respondsTo | has the method |
| def child extends makeSuperObject(parent, ...) { ... } | inheritance |
| object.method(para) | method invocation |
| object <- method(para)(4) | method invocation |
| object.method() | method invocation (with no parameter) |
| o.__getAllegedType().getMessageTypes() | methods available |
| def object_name { ... } | object creation |
| type.accepts(object) / object =~ v : type | testing class membership |
| def name := <import:p.name> | import (selectively) |
| . | package scope |
Unknown:
declare
| s[n] | accessing n-th character |
| toChar | ascii to character |
| 'z' | character "z" |
| toInteger | character to ascii |
| "" + e | convert something to a string (see also string interpolation) |
| * | duplicate n times |
| s(n,m+1) | extract a substring |
| startOf | locate a substring |
| lastStartOf | locate a substring (starting at the end) |
| all strings allow multi-line strings | multi-line |
| + | string concatenation |
| == != | string equality & inequality |
| size | string size |
| "..." | strings (with no interpolation of variables) |
| toUpperCase / toLowerCase | upper / lower case character |
| toUpperCase / toLowerCase | uppercase / lowercase / capitalized string |
Unknown:
strings (with interpolation of variables)
strings (end-of-line (without writing the real CR or LF character))
serialize (marshalling)
unserialize (un-marshalling)
sprintf-like
simple print
| false | false value |
| ! | logical not |
| || / && | logical or / and (short circuit) |
| true | true value |
| for v in l ... | for each element do something |
| pop | get the last element and remove it |
| contains | is an element in the list |
| for i => v in l | iterate with index |
| rjoin | join a list of strings in a string using a glue string |
| last | last element |
| + | list concatenation |
| [ a, b, c ](5) | list constructor |
| size | list size |
| a[i] | list/array indexing |
| sort(6) | sort |
Unknown:
list flattening
adding an element at the beginning (list cons)
adding an element at index
adding an element at the end
first element
all but the first element
get the first element and remove it
smallest / biggest element
remove duplicates
reverse
| h[k] | dictionary (access: read/write) |
| [ a => b, c => d ] | dictionary (constructor) |
| maps | dictionary (has the key ?) |
| getKeys | dictionary (list of keys) |
| getValues | dictionary (list of values) |
| removeKey | dictionary (remove by key) |
| a ..! b | range (inclusive .. exclusive) |
| a .. b | range (inclusive .. inclusive) |
| . | record (selector) |
| [ a, b, c ] | tuple constructor |
| Tuple[Typ1, Typ2, Typ3] | tuple type |
Unknown:
computable tuple (these are a kind of immutable lists playing a special role in parameter passing) (empty tuple)
computable tuple (these are a kind of immutable lists playing a special role in parameter passing) (1-uple)
computable tuple (these are a kind of immutable lists playing a special role in parameter passing) (using a tuple for a function call)
reference (pointer) (creation)
reference (pointer) (dereference)
optional value (null value)
optional value (value)
optional value (null coalescing)
dictionary (merge)
| & / | / ^ | bitwise operators (and / or / xor) |
| ** | exponentiation (power) |
| log | logarithm (base e) |
| % | modulo (modulo of -3 / 2 is -1) |
| %% | modulo (modulo of -3 / 2 is 1) |
| - | negation |
| 1000., 1E3 | numbers syntax (floating point) |
| 1_000, 10_00, 100_0 | numbers syntax (integer thousand-separator) |
| 0xf | numbers syntax (integers in base 2, octal and hexadecimal) |
| 1000 | numbers syntax (integers) |
| sqrt / exp / abs | square root / e-exponential / absolute value |
| sin / cos / tan | trigonometry (basic) |
| / round / floor / ceil | truncate / round / floor / ceil |
Unknown:
addition / subtraction / multiplication / division
random (random number)
random (seed the pseudo random generator)
operator priorities and associativities
trigonometry (inverse)
logarithm (base 10)