The "Missing:"s below indicate that an entry is incomplete.
{ ... } | block (grouping statements, especially when statements are not expressions) |
( ... ) (9) | 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) |
-lt -gt -le -ge | comparison |
= != | equality / inequality (shallow) |
`...` | runtime evaluation |
case-sensitive | tokens (case-sensitivity (keywords, variable identifiers...)) |
UPPER_CASE | tokens (if case sensitive, what is the standard way for scrunching together multiple words) |
[_a-zA-Z][_a-zA-Z0-9]* | tokens (variable identifier regexp) |
= | variable assignment or declaration (assignment) |
Missing:
documentation comment
information about the current line and file
grouping expressions
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) |
f() { ... } | function definition |
return | function return value (breaks the control flow) |
Missing:
function called when a function is not defined (in dynamic languages)
runtime inspecting the caller information
return | breaking control flow (returning a value) |
if c; then b; fi | if_then |
if c; then b1; elif c2; then b2; else b3; fi | if_then_else |
for ((x = 0; x < 10; x++)); do ...; done | loop (for "a la C" (while + initialisation)) |
for i in `seq 10 -1 1`; do expr; done | loop (for each value in a numeric range, 1 decrement) |
for i in `seq 1 10`; do expr; done | loop (for each value in a numeric range, 1 increment (see also the entries about ranges)) |
for i in `seq 1 2 10`; do expr; done | loop (for each value in a numeric range, free increment) |
while cond; do expr; done | loop (while condition do something) |
case val in v1) statement1 ;; v2|v3) statement23 ;; *) statement_else ;; esac | multiple selection (switch) |
; | sequence |
end-of-line | sequence |
Missing:
loop (forever loop)
loop (do something until condition)
breaking control flow (goto (unconditional jump))
breaking control flow (continue / break)
exception (throwing)
exception (catching)
Missing:
package scope
declare
import
"z" | character "z" |
echo (51) | simple print (on strings) |
$a$b | string concatenation |
= != | string equality & inequality |
'...' | strings (verbatim) |
<<'MARK' ... MARK | strings (verbatim) |
"... $v ..." | strings (with interpolation) |
<<MARK ... $v ... MARK | strings (with interpolation) |
Missing:
strings (end-of-line (without writing the real CR or LF character))
multi-line
serialize (marshaling)
unserialize (un-marshaling)
sprintf-like
string size
duplicate n times
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 / exit status different from 0 | false value |
true / exit status 0 | true value |
Missing:
logical not
logical or / and
seq | range (inclusive .. inclusive) |
Missing:
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)
record selector
dictionary (constructor)
dictionary (access)
dictionary (has the key ?)
dictionary (remove by key)
dictionary (list of keys)
dictionary (list of values)
+ / - / * / / | addition / subtraction / multiplication / division |
- | negation |
1000 | numbers syntax (integers) |
mathematical | operator priorities and associativities (addition vs multiplication) |
Missing:
numbers syntax (integers in base 2, octal and hexadecimal)
numbers syntax (integer thousand-seperator)
exponentiation (power)
random
square root / e-exponential / absolute value
trigonometry (basic)
trigonometry (inverse)
logarithm
modulo
truncate / round / floor / ceil
bitwise operators