The "Missing:"s below indicate that an entry is incomplete.
| indentation (9) | block (grouping statements, especially when statements are not expressions) |
| # | commenting (until end of line) |
| < > <= >= | comparison |
| min / max | comparison (min / max (binary or more)) |
| a <=> b | comparison (returns 3 values (i.e. inferior, equal or superior)) |
| == != | equality / inequality (deep) |
| ( ... ) | grouping expressions |
| indentation | grouping expressions |
| space (8) | grouping expressions |
| case-sensitive | tokens (case-sensitivity (keywords, variable identifiers...)) |
| underscores | tokens (if case sensitive, what is the standard way for scrunching together multiple words) |
| [_a-z][_a-zA-Z0-9]*[!?']* | tokens (variable identifier regexp) |
| = | variable assignment or declaration (both) |
| := | variable assignment or declaration (both) |
Missing:
documentation comment
information about the current line and file
breaking lines (useful when end-of-line and/or indentation has a special meaning)
force garbage collection
| (a >) | partial application (in the examples below, a normal call is "f(a,b)") (give the first argument to operator ">") |
| f(a,) | partial application (in the examples below, a normal call is "f(a,b)") (give the first argument) |
| (> a) | partial application (in the examples below, a normal call is "f(a,b)") (give the second argument to operator ">") |
| f(,b) | partial application (in the examples below, a normal call is "f(a,b)") (give the second argument) |
| a, b -> ... | anonymous function |
| f(a,b,...) | function call |
| f() (19) | function call (with no parameter) |
| ~ | function composition |
| f(para1, para2, ...) = ... | function definition |
Missing:
function return value
identity function
| raise | exception (throwing) |
| if c then b | if_then |
| if c then b1 else b2 | if_then_else |
| loop | loop (forever loop) |
val. v1 -> expr1 v2 -> expr2 _ -> expr_else | multiple selection (switch) |
| ; | sequence |
| end-of-line | sequence |
Missing:
loop (while condition do something)
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))
breaking control flow (returning a value)
breaking control flow (continue / break)
exception (catching)
| !! | annotation (or variable declaration) |
| n = t | declaration |
Missing:
cast
mutability, constness (type of a mutable value)
mutability, constness (type of a constant value)
| object.method(para) | method invocation |
| object.method | method invocation (with no parameter) |
Missing:
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
current instance
accessing parent method
| :: | package scope |
Missing:
declare
import
| "z" | character "z" |
| Char | character type name |
| to_string | convert something to a string (see also string interpolation) |
| times | duplicate n times |
| simple print (on strings) | |
| println (51) | simple print (on strings) |
| printf | simple print (printf-like) |
| sprintf | sprintf-like |
| + | string concatenation |
| == != | string equality & inequality |
| q(...(...)...) | strings (verbatim) |
| "... {v} ..." | strings (with interpolation) |
| qq(...(... {v} ...)...) | strings (with interpolation) |
| String | type name |
Missing:
strings (end-of-line (without writing the real CR or LF character))
multi-line
serialize (marshaling)
unserialize (un-marshaling)
string size
upper / lower case character
uppercase / lowercase / capitalized string
ascii to character
character to ascii
accessing n-th character
extract a substring
locate a substring
locate a substring (starting at the end)
| False | false value |
| not | logical not |
| || / && | logical or / and (short circuit) |
| True | true value |
Missing:
type name
| unzip | 2 lists from a list of couples |
| : | adding an element at the beginning (list cons) (return the new list (no side-effect)) |
| push | adding an element at the end (return the new list (no side-effect)) |
| foldl | f(... f(f(init, e1), e2) ..., en) |
| foldr | f(e1, f(e2, ... f(en, init) ...)) |
| find | find an element |
| each | for each element do something |
| shift! | get the first element and remove it |
| pop! | get the last element and remove it |
| member? | is an element in the list |
| exists? | is the predicate true for an element |
| all? | is the predicate true for every element |
| each_with_index | iterate with index |
| filter | keep elements matching |
| + | list concatenation |
| [ a, b, c ] | list constructor |
| flatten | list flattening (one level depth) |
| zip | list of couples from 2 lists |
| to_list | list out of a bag |
| size | list size |
| a[i] | list/array indexing |
| uniq | remove duplicates |
| reverse | reverse |
| minimum / maximum | smallest / biggest element |
| sort | sort |
| sort_by | sort |
| partition | split a list in 2 based on a predicate |
| map | transform a list (or bag) in another one |
Missing:
type name
adding an element at index
first element
all but the first element
last element
transform two lists in parallel
join a list of strings in a string using a glue string
lookup an element in a association list
| ((a)) | 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) (empty tuple) |
| t | computable tuple (these are a kind of immutable lists playing a special role in parameter passing) (using a tuple for a function call) |
| a .. b | range (inclusive .. inclusive) |
| r { field } | record selector |
| a, b, c | tuple constructor |
| t1, ..., tn | tuple type |
Missing:
reference (pointer) (creation)
reference (pointer) (dereference)
optional value (null value)
optional value (value)
optional value (type name)
dictionary (type name)
dictionary (constructor)
dictionary (access)
dictionary (has the key ?)
dictionary (remove by key)
dictionary (list of keys)
dictionary (list of values)
| + / - / * / / | addition / subtraction / multiplication / division |
| ** | exponentiation (power) |
| - | negation |
| 1000, 1000.0, 1E3 (78) | numbers syntax (decimals) |
| 1_000 | numbers syntax (integer thousand-seperator) |
| 1000 | numbers syntax (integers) |
| mathematical | operator priorities and associativities (addition vs multiplication) |
Missing:
type name
numbers syntax (integers in base 2, octal and hexadecimal)
random
square root / e-exponential / absolute value
trigonometry (basic)
trigonometry (inverse)
logarithm
modulo
truncate / round / floor / ceil
bitwise operators