The "Unknown:"s below indicate that an entry is incomplete.
| { ... }(1) | block (grouping statements, especially when statements are not expressions) |
| nothing needed | breaking lines (useful when end-of-line and/or indentation has a special meaning) |
| /* ... */ | commenting (non nestable) |
| // | commenting (until end of line) |
| < > <= >= | comparison |
| == != | equality / inequality (deep) |
| ( ... ) | grouping expressions |
| eval | runtime evaluation |
| = | variable assignment or declaration (assignment) |
Unknown:
documentation comment
information about the current line and file
tokens (case-sensitivity (keywords, variable identifiers...))
tokens (what is the standard way for scrunching together multiple words)
tokens (variable identifier regexp)
comparison (returns 3 values (i.e. inferior, equal or superior))
comparison (min / max (binary or more))
force garbage collection
| f(a,b,...) | function call |
| f() | function call (with no parameter) |
| typ0 f(typ1 para1, typ2 para2, ...) { ... } | function definition |
| return(2) | function return value (breaks the control flow) |
Unknown:
function called when a function is not defined (in dynamic languages)
runtime inspecting the caller information
| continue / break | breaking control flow (continue / break) |
| return(2) | breaking control flow (returning a value) |
| if (c) ... | if_then |
| if (c) b1 else b2 | if_then_else |
| c ? b1 : b2 | if_then_else |
| repeat ... until (c) | loop (do something until condition) |
| while (c) ... | loop (while condition do something) |
| ; | sequence |
Unknown:
multiple selection (switch)
loop (forever loop)
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))
breaking control flow (goto (unconditional jump))
exception (throwing)
exception (catching)
| t v | annotation (or variable declaration) |
Unknown:
declaration
cast
mutability, constness (type of a mutable value)
mutability, constness (type of a constant value)
Unknown:
method invocation
method invocation (with no parameter)
object creation
object cloning
manually call an object's destructor
class declaration
testing class membership
get the type/class corresponding to an object/instance/value
methods available
inheritance
has the method
current instance
accessing parent method
| { module "p"; ... } | declare |
| import "p" | import (everything into current namespace) |
| :: | package scope |
| tostring | convert something to a string (see also string interpolation) |
| substring | extract a substring |
| find | locate a substring |
| all strings allow multi-line strings | multi-line |
| + | string concatenation |
| == != | string equality & inequality |
| size | string size |
| "\n" | strings (end-of-line (without writing the real CR or LF character)) |
| "..." | strings (with no interpolation of variables) |
| string | type name |
| toupper / tolower | uppercase / lowercase / capitalized string |
Unknown:
character type name
character "z"
strings (with interpolation of variables)
serialize (marshalling)
unserialize (un-marshalling)
sprintf-like
simple print
duplicate n times
upper / lower case character
ascii to character
character to ascii
accessing n-th character
locate a substring (starting at the end)
| false | false value |
| ! | logical not |
| || / && | logical or / and (short circuit) |
| true | true value |
| boolean | type name |
| prepend | adding an element at the beginning (list cons) (side-effect) |
| add | adding an element at the end (side-effect) |
| find | find an element |
| foreach(t v, l, { ... }) | for each element do something |
| contains | is an element in the list |
| filter | keep elements (matching) |
| merge | list concatenation |
| [ a, b, c ](3) | list constructor |
| flatten | list flattening (one level depth) |
| size | list size |
| a[i]:default | list/array indexing |
| toset | remove duplicates |
| sort(4) | sort |
| maplist | transform a list (or bag) in another one |
Unknown:
type name
adding an element at index
first element
all but the first element
last element
get the first element and remove it
get the last element and remove it
smallest / biggest element
join a list of strings in a string using a glue string
iterate with index
reverse
| h[k]:default | dictionary (access: read) |
| h[k] | dictionary (access: write) |
| $[ a: b, c: d ] | dictionary (constructor) |
| haskey | dictionary (has the key ?) |
| remove | dictionary (remove by key) |
Unknown:
tuple type
tuple constructor
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)
record (type declaration)
record (selector)
union type declaration
enumerated type declaration
dictionary (type name)
dictionary (list of keys)
dictionary (list of values)
dictionary (merge)
range
| & / | | bitwise operators (and / or / xor) |
| ~ | bitwise operators (bitwise inversion) |
| << / >> | bitwise operators (left shift / right shift / unsigned right shift) |
Unknown:
type name
numbers syntax (integers)
numbers syntax (integers in base 2, octal and hexadecimal)
numbers syntax (floating point)
addition / subtraction / multiplication / division
exponentiation (power)
negation
random (random number)
random (seed the pseudo random generator)
operator priorities and associativities
square root / e-exponential / absolute value
trigonometry (basic)
trigonometry (inverse)
logarithm (base e)
logarithm (base 10)
modulo
truncate / round / floor / ceil