Syntax

Here is an example footnote. ↩

‘r’ indicates (r)adix / base – default 10 (decimal) if omitted. Ex: 2r binary & 16r hex. big-digit(s) vary by the radix used. ↩

Negative simple-integer can be confused with subtract math-operator. ↩

Decimal part of real-literal is optional if Real type can be inferred from context or if the exponent part is present. ↩

List type specified if the optional list-class and appropriate constructor-name is supplied (also see instantiation). If the type is not supplied, then a type is inferred using the initial items – if there are no initial items then Object used as default item type). ↩

[Also known as: code block, anonymous function or lambda expression.] Optional ‘^’ or parameters or both must be provided (unless used in closure-tail-args where both are optional). Optional expression (which may not be code-block or closure) will be captured and used as receiver/this for the code-block – if not provided this is inferred. Optional ‘_’ indicates it is durational (like a coroutine) – if not present durational/immediate inferred via code-block. Parameter types, return type, scope, whether surrounding this or temporary/parameter variables are used and captured may all be inferred if omitted. ↩

Note that scoping is not necessary – instance names may not be overridden and classes and implicit identifiers effectively have global scope. ↩

Optional expression can be used to access data member from an object – if omitted, this is inferred. ↩

’@’ indicates instance data member and ‘@@’ indicates class instance data member. ↩

If class-name absent Actor inferred or desired type if known. If optional ‘?’ is present and object not found at runtime then result is nil else assertion error occurs. Optional hash mark ‘#’ indicates no lookup - just return name identifier validated by class type. ↩

A method using class-name allows explicit conversion similar to class-conversion except that the method is always called. ↩

Optional ‘?’ used as convention to indicate predicate variable or method of return type Boolean (true or false). ↩

Destructor calls are only valid in the scope of another destructor’s code-block. ↩

Only valid in the scope of a code-block. ↩

May not be used as an argument. Only a named-spec is valid as an argument which looks similar. ↩

If an invoke-call’s optional expression (the receiver) is omitted, ‘this.’ is implicitly inferred. ↩

If class-instance can be inferred then it may be omitted. When expression used rather than class-instance lots of syntactic sugar is provided: expr!ctor() is alias for ExprClass!ctor(expr) – ex: num!copy equals Integer!copy(num); brackets are optional for invocation-args if it can have just the first argument; a constructor-name of ! is an alias for !copy – ex: num! equals Integer!copy(num); and if expr!ident does not match a constructor it will try ExprClass!copy(expr).ident – ex: str!uppercase equals String!copy(str).uppercase. ↩

Akin to expr.invoke(...) or expr._invoke(...) depending if expression immediate or durational – and if enough context is available the arguments are compile-time type-checked plus adding any default arguments. ↩

Gets item (or sets item if binding present) at specified index object. Syntactic sugar for at() or at_set(). ↩

If receiver ‘List’ type - each item sent call – coroutines called using % – sync, %> – race concurrency depending on delimiter. If receiver empty list or nil invocation is skipped. If not list or nil then executes like normal invoke call – i.e. ‘%’ is synonymous to ‘.’. ↩

Every operator has a named equivalent. For example := and assign(). Operators do *not* have a special order of precedence – any order other than left to right must be indicated by using code block brackets (‘[’ and ‘]’). ↩

In order to be recognized as single subtract ‘-’ expression and not an expression followed by a second expression that starts with a minus sign, the minus symbol ‘-’ must either have whitespace following it or no whitespace on either side. ↩

See math-operator footnote about subtract on how to differentiate from a negation ‘-’ prefix operator. ↩

bracketed-args may be omitted if the invocation can have zero arguments. ↩

Routines with last send parameter as mandatory closure may omit brackets ‘()’ and closure arguments may be simple code-block (omitting ‘^’ and parameters and inferring from argument parameter context). Default arguments indicated via comma ‘,’ separators. ↩

If a temporary is defined in the return-arg, it has scope for the entire surrounding code block. ↩

Named arguments may only be used at end of the argument list – and once used may only be followed by other named arguments. Named arguments may also specify an argument for a group-param, but must be compatible List object. Named arguments evaluated in parameter index order regardless of order they appear since defaults may reference earlier parameters. Note that bind may not be used as an argument. ↩

Compiler *hint* that expression evaluates to specified class – otherwise error. class-desc optional if desired type can be inferred. If expression is variable-identifier then parser updates type context. [Debug: runtime ensures class specified is received.] ↩

Explicit conversion to specified class. class-name optional if desired type inferable. Ex: 42>>String calls conversion method Integer@String() i.e. 42.String() - whereas "hello">>String generates no extra code and is equivalent to "hello". ↩

expr1??expr2 is essentially equivalent to if expr1.nil? [expr2] else [expr1<>TypeNoneRemoved]. ↩

The optional instance-name identifies the loop for specific reference by a loop-exit which is useful for nested loops. ↩

Only valid in the code block scope of the loop that it references. ↩

2+ durational expressions run concurrently and next expression executed when *all* expressions returned (result nil, return args bound in order of expression completion). ↩

2+ durational expressions run concurrently and next expression executed when *fastest* expression returns (result nil, return args of fastest expression bound) and other expressions are *aborted*. ↩

Durational expression run concurrently with surrounding context and the next expression executed immediately (result InvokedCoroutine). expression is essentially a closure with captured temporary variables to ensure temporal scope safety. Any return arguments will be bound to the captured variables. ↩

Rather than inheriting the caller’s updater Mind object, durational expressions in the second expression are updated by the mind object specified by the first expression. ↩

If optional ‘?’ is used in query/predicate method name, use ‘-Q’ as a substitute since question mark not valid in a file name. ↩

Only immediate calls are permissible in the code block. If code-block is absent, it is defined in C++. ↩

If code-block is absent, it is defined in C++. ↩

A file name appended with ‘C’ indicates that the file describes class members rather than instance members. ↩

Optional class-desc is compiler hint for expected type of member variable. If class omitted, Object inferred or Boolean if data-name ends with ‘?’. If data-name ends with ‘?’ and class-desc is specified it must be Boolean. ↩

The context / file where an annotation is placed limits which values are valid. ↩

Optional class-desc is return class – if type not specified Object is inferred (or Boolean type for predicates or Auto_ type for closures) for nested parameters / code blocks and InvokedCoroutine is inferred for coroutine parameters. ↩

The optional binding indicates the parameter has a default argument (i.e. supplied expression) when argument is omitted. ↩

If optional class-desc is omitted Object is inferred or Auto_ for closures or Boolean if variable-name is predicate and ends with ‘?’. If variable-name ends with ‘?’ and class-desc is specified it must be Boolean. ↩

Object inferred if no classes specified. Class of resulting list bound to instance-name is class union of all classes specified. ↩

Indicates that the class is any one of the classes specified and which in particular is not known at compile time. ↩

‘_’ indicates durational (like coroutine), ‘+’ indicates durational or immediate (coroutine or method) and lack of either indicates immediate (like method). Class ‘Closure’ matches any closure interface. Identifiers and defaults used for closure arguments without parameters. ↩

List can be any class derived from List. If class-desc in item class descriptor is omitted, Object is inferred when used as a type or the item type is deduced when used with a *list-literal. A list-class of any item type can be passed to a simple untyped List class. ↩

wsr is an abbreviation for (w)hite (s)pace (r)equired. ↩

Special escape characters: ‘n’ - newline, ‘t’ - tab, ‘v’ - vertical tab, ‘b’ - backspace, ‘r’ - carriage return, ‘f’ - formfeed, and ‘a’ - alert. All other characters resolve to the same character including ‘\’, ‘"’, and ‘'’. ↩