Functions

Functions are a way to write repeatedly occuring computations only once, but use them wherever needed. They also help in structuring longer scripts into smaller, easily understandable units. By putting often occuring functions into separate modules (see section * ()), function libraries can be created.

Functions normally have a set of parameters as input and return a single function result as output. Since the function result can be an array, an arbitrary number of values can be returned.

The function is left by returning a value with a return statement. If the function is left by reaching its end, null is returned.

The following example declares a function sqrt computing the square root of a number x greater than or equal to 1, then calls it with parameters x=2 and x=9:

This is quite a simple function with a single parameter x and a simple function result (the value of y).

Multiple parameters are separated by commas. The following function find finds the index of the first element in an array a with a value equal to x (there is a standard function for this: array.index).

A function can be recursive, i.e. can call itself: the following function clone returns a full copy of its parameter t. It uses array.copy to copy all the elements, and .isarray to test whether t is an array.

If a function returns an array, the call can be followed by expressions in brackets accessing certain elements:

Function parameters are like local variables; they can optionally be declared to hold an instance of a given class. Likewise, the function can be declared to return an instance. See * () for examples and details.

• Optional Parameters
• Forward Declaration
• Function References

Optional Parameters

Optional parameters are parameters with a default value: if the parameter is omitted, the default value is assumed. The expression to compute the default value can be any expression which is valid in the global context (i.e. it cannot use a preceding function parameter). It is evaluated when the function is called, not when the function is declared.

When calling a function, the number of actual parameters must not be less than the number of mandatory parameters in the declaration of the function, and not be greater than the total number of declared parameters.

The following rewrites function find by adding an optional parameter start indicating the position to start searching at. The default value of start is 0, so calling find with only two parameters produces exactly the same result as before:

Functions with optional parameters can have options for simplified syntax in interactive use (see section * ()). Options are simply single character names for optional parameters.

Forward Declaration

Functions must be declared before they can be used. This means that if two functions call each other, at least one must be declared with forward and implemented later. In the following example, either f or g must be forward declared, since function f calls function g and vice versa:

The default values of the optional parameters of the forward declared function are only used to mark optional parameters, their values are ignored. The default values are taken from the function implementation. The number of mandatory and optional parameters in forward declaration and implementation must match.

Function References

Function references allow to change the function called in an expression during the execution of a script: when a function reference is assigned to a variable or a parameter, the function can be called via the variable. The reference of a function is obtained by prefixing it with an ampersand character &:

Function references are often used to pass a function as a parameter to another function: the function integ approximates the integral of f from a to b:

Navigation