Lambda closures are a form of VBFC: a special data type that can be evaluated as code. The data type is "closure". An example of it's use is to give a closure value to a property, which is evaluated when queried. Closures can make use of operators, efuns and non-static local functions. A closure can be created with the lambda() efun. There are two ways to use it. The first creates a fast closure operator, directly based on an efun of operator: lambda(">") returns a closure for the larger-than operator. It can be evaluated with the apply() efun: apply(lambda(">"), 2, 1) returns 1, because 2 is larger than 1. This type of simple closure is especially well-suited for use in efuns such as filter_array(), filter_mapping() etc. For instance, sort_array(arr, lambda(">")) can be used. The other kind of closure is created like this: closure expr; expr = lambda(({ "'x", "'y" }), ({ "->", "'x", "'y" })); The first argument to the lambda() efun is a array of parameter names. Parameter names must be strings that start with a quote, followed by an identifier. The second argument is an array, of which the first element is an efun, an operator, a closure operator or a local function name (in the example above, it is the operator ->). The other arguments must be expressions; parameter names will be replaced by the values that the closure is called with. An expression can itself be a closure, for instance: closure add, expr; add = lambda(({ "'x", "'y" }), ({ "+", "'x", "'y" })); expr = lambda(({ "'x", "'y", "'z" }), ({ "->", "'x", ({ add, "'y", "'z" }) })); This creates a closure "expr" with three arguments, the last two of which are added together to form the function name. The above closure is equivalent with the following LPC code: call_other(x, y + z); There is an important difference between the "short" closures and the "long" closures: the "long" closures evaluate their arguments (if they are variables or a array, the first element of which is a closure); the "short" closures do not. For example, closure short, long; short = lambda("+"); long = lambda(({ "'x", "'y" }), ({ "+", "'x", "'y" })); apply(short, 1, 2) == 3 apply(long, 1, 2) == 3 /* assume that 'a == 1 and 'b == 2 */ apply(short, "'a", "'b") == "'a'b" apply(long, "'a", "'b") == 3 Apart from efuns and operators, the following closure operators can be used: "," <expr>+ <expr1>, <expr2>, ..., <exprn> "?" ( <test> <result> )* <default> if (<test1>) return <result1>; else if (<test2>) return <result2>; ... else return <default>; "?!" ( <test> <result> )* <default> opposite of "?" "while" <test> <result> <expr> while (<test>) <expr>; return <result>; "do" <expr> <test> <result> do <expr> while (<test>); return <result>; "=" ( <var> <expr> )+ <var1> = <expr1>; <var2> = <expr2>; ... <varn> = <exprn>; (other assignment operators also work) "[" <arrstr> <index> <arrstr>[<index>] "[.." <arrstr> <index1> <index2> <arrstr>[<index1> .. <index2>] "'" <expr> <expr>, without evaluating it All of the closure operators above evaluate their arguments, except for "'", which should only be used as a "short" closure. All efuns are supported, except for ed(), input_to() and set_light() (can you figure out why?). If an efun supercedes a kfun, the kfun is not supported (for instance, "rm" works, "remove_file" doesn't). The "closureness" of a value can be tested with the closurep() efun.