Up: Index. Previous: Introduction. Next: Menus.

Language

Lambda expressions are built based on four simple rules.

  1. A single identifier is a lambda expression. Lambda Calculator will treat any string of non-space characters as an identifier, as long as it does not contain a backslash, period, parenthesis, bracket, or brace.

  2. A function can be applied to an argument by writing a lambda expression representing the function and then another lambda expression representing the argument. The expression "fact 4" would represent a call to the fact function passing 4 as its parameter. Note that parentheses are not necessary surrounding the function argument.

  3. A lambda expression can be abstracted by writing a lambda (represented with a backslash in Lambda Calculator), then an identifier, then a period, then the lambda expression. This represents a function whose parameter is named as in the identifier and whose return value is the value computed by the lambda expression. For example, "x.x" represents the identity function.

  4. Finally, you can give parentheses to clarify precedence. You can alternatively use brackets ('[]') or braces ('{}'); these alternatives can be useful when you have a long expression and have a difficult time matching parentheses.

Without parentheses, a function application has a higher order of precedence than function abstraction, and function applications are left-associative. For example, the expression "x.f g x" would represent a function that takes in an argument x and returns the result of applying g to f, then x to the function that this returns. If you want instead to pass x to g and the result to f, you would need parentheses: "x.f (g x)". This latter expression would represent a function the functional composition of f and g.

Thus, when we consider the lambda expression

(x.* x x) (- 3 1)
we see that Lambda Calculator will understand this as the application of the argument (- 3 1) (whose value is 2) into the function taking x as a parameter and returning the value of * x x. The value of * 2 2, and hence of this lambda expression, is 4.

The following lambda expression is a more difficult one.

(f.z.f (f z)) (x.* x x) (- 3 1)
The first parenthesized term represents a function that takes f as a parameter and returns a function taking z as a parameter and returning the value of f (f z). In this case, we pass the function "x.* x x" into this function as f, and so we get the function taking z as a parameter and returning the value of
(x.* x x) ((x.* x x) z)
Into this function we pass the value of (- 3 1), which is 2. Simplifying our expression, we get
(x.* x x) (* 2 2)
(x.* x x) 4
* 4 4
Thus, we arrive at 16. (Note, however, that Lambda Calculator would simplify the expression in a different order.)

The applied calculus

When the "Use Applied Calculus" option is selected (as it is by default), the engine includes a variety of computational functions already.

+, -, *, / take two numerical identifiers and return an identifier representing the binary operation applied to them.
<, >, <=, >=, =, /= take two numerical identifiers and return the identifier true or false representing how they compare. (The /= function represents inequality.)
if take three values, the first being the identifier true or false, returning the second value if the identifier is true and the third if it is false.

Note: If you have selected the applicative evaluation, the built-in if function will not necessarily compute as you might expect. The engine will attempt to evaluate all three arguments first before applying the if function, which could lead to unnecessary infinite computation.

Up: Index. Previous: Introduction. Next: Menus.