The "Unknown:"s below indicate that an entry is incomplete.
| { ... } | block (grouping statements, especially when statements are not expressions) |
| /* ... */ | commenting (non nestable) |
| // | commenting (until end of line) |
| < > <= >= | comparison |
| min / max | comparison (min / max (binary or more)) |
| equal | equality / inequality (deep) |
| == != | equality / inequality (shallow) |
| gc | force garbage collection |
| ( ... ) | grouping expressions |
| __LINE__ __FILE__ | information about the current line and file |
| compile_string | runtime evaluation |
| case-sensitive | tokens (case-sensitivity (keywords, variable identifiers...)) |
| CamelCase for modules and classes, ALLCAPS for macros, underscores for methods, constants and variables | tokens (what is the standard way for scrunching together multiple words) |
| = | variable assignment or declaration (assignment) |
Unknown:
documentation comment
tokens (variable identifier regexp)
breaking lines (useful when end-of-line and/or indentation has a special meaning)
comparison (returns 3 values (i.e. inferior, equal or superior))
| lambda(typ1 para1, typ2, para2, ...) { ... }; | anonymous function |
| f(a,b,...) | function call |
| f() | function call (with no parameter) |
| typ0 f(typ1 para1, typ2 para2, ...) { ... } | function definition |
| void f(typ1 para1, typ2 para2, ...) { ... } | function definition (procedures) |
| return(1) | function return value (breaks the control flow) |
| backtrace | runtime inspecting the caller information |
Unknown:
function called when a function is not defined (in dynamic languages)
| continue / break | breaking control flow (continue / break) |
| return(1) | breaking control flow (returning a value) |
| catch(...) or catch { ... }; | exception (catching) |
| throw | exception (throwing) |
| if (c) ... | if_then |
| if (c) b1 else b2 | if_then_else |
| do ... while (!c) | loop (do something until condition) |
| for | loop (for "a la C" (while + initialisation)) |
| for (int i = 1; i <= 10; i += 2) ... | loop (for each value in a numeric range, free increment) |
| while (c) ... | loop (while condition do something) |
switch (val) {
case v1: ...; break;
case v2: case v3: ...; break;
default: ...;
} | multiple selection (switch) |
| , | sequence |
| ; | sequence |
Unknown:
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)
breaking control flow (goto (unconditional jump))
| t v | annotation (or variable declaration) |
| (t) e | cast (computed conversion (calls an internal or a user-defined function)) |
| [t] e | cast (downcast (need runtime checking)) |
| [t] e | cast (upcast) |
| typedef t n | declaration |
Unknown:
mutability, constness (type of a mutable value)
mutability, constness (type of a constant value)
| class | class declaration |
| this | current instance |
| object_program | get the type/class corresponding to an object/instance/value |
| object->method | has the method |
| inherit | inheritance |
| destroy | manually call an object's destructor |
| object->method(para) | method invocation |
| object["method"](para) | method invocation |
| object->method() | method invocation (with no parameter) |
| object["method"]() | method invocation (with no parameter) |
| indices | methods available |
| class_name(...) | object creation |
| Program.inherits or Program.implements | testing class membership |
Unknown:
object cloning
accessing parent method
| attached to each name (public, private...) | declare (selective export) |
| import | import (everything into current namespace) |
Unknown:
package scope
| s[n] | accessing n-th character |
| 'z' | character "z" |
| (string) e | convert something to a string (see also string interpolation) |
| * | duplicate n times |
| s[n..m] | extract a substring |
| search | locate a substring |
| write | simple print (on strings) |
| write | simple print (printf-like) |
| sprintf | sprintf-like |
| + | string concatenation |
| == !=(Vimscript: whether or not == and != are case-sensitive depends on user settings.) | string equality & inequality |
| sizeof | string size |
| "\n" | strings (end-of-line (without writing the real CR or LF character)) |
| "..." | strings (with no interpolation of variables) |
| string | type name |
| upper_case / lower_case | upper / lower case character |
Unknown:
strings (with interpolation of variables)
multi-line
serialize (marshalling)
unserialize (un-marshalling)
uppercase / lowercase / capitalized string
ascii to character
character to ascii
locate a substring (starting at the end)
| 0(2) | false value |
| ! | logical not |
| || / && | logical or / and (short circuit) |
| anything not false | true value |
| reduce(3) | f(... f(f(init, e1), e2) ..., en) |
| rreduce | f(e1, f(e2, ... f(en, init) ...)) |
| search | find an element |
| foreach | for each element do something |
| has_value | is an element in the list |
| foreach(l; typ0 i; typ1 v) { ... } | iterate with index |
| l * s | join a list of strings in a string using a glue string |
| filter | keep elements (matching) |
| a[-1] | last element |
| + | list concatenation |
| ({ a, b, c }) | list constructor |
| flatten | list flattening (recursive) |
| sizeof | list size |
| a[i] | list/array indexing |
| uniq | remove duplicates |
| uniq2 | remove duplicates |
| reverse | reverse |
| min / max | smallest / biggest element |
| sort(4) | sort |
| map | transform a list (or bag) in another one |
Unknown:
type name
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
get the last element and remove it
| h["k"] or h->k | dictionary (access: read/write) |
| ([ a:b, c:d ]) | dictionary (constructor) |
| h[k] | dictionary (has the key ?) |
| indices | dictionary (list of keys) |
| values | dictionary (list of values) |
| m_delete | 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 (merge)
range
| & / | / ^ | bitwise operators (and / or / xor) |
| ~ | bitwise operators (bitwise inversion) |
| << / >> | bitwise operators (left shift / right shift / unsigned right shift) |
| pow | exponentiation (power) |
| log | logarithm (base e) |
| % | modulo (modulo of -3 / 2 is 1) |
| - | negation |
| 1000.0, 1E3 | numbers syntax (floating point) |
| 0b1, 07, 0xf(5) | numbers syntax (integers in base 2, octal and hexadecimal) |
| 1000 | numbers syntax (integers) |
| sqrt / / | square root / e-exponential / absolute value |
| sin / cos / tan | trigonometry (basic) |
| asin / acos / atan(6) | trigonometry (inverse) |
| int / round / floor / ceil | truncate / round / floor / ceil |
Unknown:
type name
addition / subtraction / multiplication / division
random (random number)
random (seed the pseudo random generator)
operator priorities and associativities
logarithm (base 10)
| object t=Thread.Thread(f) | thread creation |