Higher-Order Instructions

In LL, three builtins for higher-order function application exist: funcall, apply, and eval. Their corresponding LLAMA instructions funcall , apply , and eval work as follows:

1. funcall :
   • First, the functional object is examined: if it is a constant function, function/ is the function to be called. If it is a structure [func arg arg], then func/arity with arity = is the function. Structures as functional objects are mainly used for lambda expressions: the free local variables of a lambda expression become the arguments of a structure (this is described in section 6.2.4).

   • In case of a structure as functional object, the structure arguments are inserted behind the place where the structure pointer is on the stack.

   • Finally, as in the ll-call instruction, the return address is pushed on the stack and execution is continued at @function/ or @func/arity, respectively. If the function is a builtin (e.g. +), the function/relation implementing it is simply executed and the result is put on the stack.

2. apply : In case of apply, there is only a minor difference to funcall: the top stack element, which must be a list, is expanded on the stack, and the length of this list minus 1 is added to the arity of the function to be called.

3. eval: The external representation (denoted as ) of the expression which has to be evaluated is embedded in a new function definition (defun %eval() ) which is executed. Subsequently, the address of the instruction behind the eval instruction is pushed as return address on the stack and execution is continued with %eval.

   Note that for eval the compiler is used at run time instead of interpreting the expression.