calling-convention ::= label
format ::= identifier
link ::= link [s] calling-convention
Functions can have a calling-convention parameter: the names and types of
the possible values are for future times (and platform specific)
placement ::= inline
generic-type ::= @ identifier
Generic code uses identifiers with an '@' prefix to indicate the placeholder
code-use ::= terminal
- Function will never return, it should only have
'my' parameters, and no further code after its call is allowed
- Function can only be used by resume.
It can not have any parameters.
- Function can use yield
- Function changes some basic (global) property.
No code may be moved from before <-> after its call by the optimizer.
- Function changes nothing except its arguments, and
also gives a identical result for constant arguments. NB: print functions are
never constant. These functions, when called with constant arguments, may be
resolved at compile time.
- Only one active instance of the function may
exists. This is done inside the function itself, so the parameter
evaluation and the call itself are not protected. Synchronized
- Function need not be available. Parameter evaluation
(including side effects) is not done when the function is not
available. Note that weak function do certain magick; see
pass ::= copy | take | use
| borrow | share
| give | present
- (In) Pass by value, a new value is made, the function gets the ownership
- take [my]
- (In) Pass by reference, the function gets the ownership
- borrow [your]
- (In/Out) Pass by reference, function does not get the ownership
- (In/Out) Pass by value - return (for example RPC calls)
- share [our]
- (In/Out) Pass a shared variable by reference
- (In) This is the odd one out. Actually use indicates that it is
either passed as borrow or as copy, but it has to be constant!
The compiler/interpreter can decide which method to choose.
Nota Bene: you can (and should) not use ==, or any other feature
which is based on the identity of the parameter.
- (Out) Return by reference, the caller gets the ownership
Return (out) value. Actually space for this paremeter is allocated by the
caller, and a reference to this space is passed to the function. Except
when the optimizer decides otherwise (TODO) like using registers
- (Out) Return a shared variable
- The default value: this parameter has to be there
- If this parameter is not present, a variable of this type is quietly
created in the 'nearest' with block in scope.
Note that a 'that automatic' parameter can be used as hidden
Also note that a 'return automatic' parameter is effectively an
optional return value
- The type of this parameter is silently promoted to 'const ' of
its original type, and all calling params of the same type are aggregated into
Note that you can use the compound structure if you have 2+ repeated
parameter of identical type.
define function foo(my repeated integer a, my repeated integer b);
my int i,j,k,l;
foo(i,j,k,l); # a.length()==3 (i,j,k), b.length()==1 (l)
foo((i,j),(k,l)); # a.length()==2 (i,j), b.length()==2 (k,l)
parameter ::= [presence] [pass change] [check] type
Shortcut: If there is no passing method and no change field then
'some const' is silently inserted.
fn-constraint ::= restriction-x
parameter-list ::= list-start [parameters] list-end
function ::= function
end-function ::= end [[s] function [s identifier]
function-contract ::= function identifier [s] parameter-list [[s] sep fn-constraint]...