Recursion is the act of calling a routine (subroutine or function) as part of its own execution. Recursion is allowed for all routines in LUX, whether they are built-in or user-defined.
The parameters of a user-defined routine are independent from instance to instance: If more than one instance of a particular user-defined routine is active at the same time, then a particular parameter in one copy of the routine is independent of the version of the same parameter in all other copies of the routine. However, the values of the parameters are lost when the routine is finished.
The strictly local variables of the routine are not covered by this rule: only a single copy of such variables exists, which is shared between all instances of the routine, and which retains its value even after the routine is finished.
It is quite easy to define a function or subroutine that keeps calling itself indefinitely. LUX leaves checking for such infinite recursion up to the user.
For example, here is a definition for a function that calculates the
factorial of a positive integer number
n (i.e., the product of all
numbers between 1 and
func fac(n) if n eq 1 then return,n return,n*fac(n-1) endfunc
If we call this function with argument
foo(2), which calls
being evaluated, three instances of
foo() are active at the same
time, each with their own independent copy of
In this particular example, the function is not waterproof against
infinite recursion. If you call the function with a number smaller than
1, or with a number that is not an integer, then it will keep calling
itself indefinitely until all those different instances of
fill up LUX’s symbol tables.