- Unlambda
Unlambda is a minimal functional
programming language invented byDavid Madore . It is based oncombinatory logic , a version of thelambda calculus that omits the lambda operator. It relies mainly on two built-in functions ("s" and "k") and an "apply" operator (written "`", the backquote character). These alone make itTuring-complete , but there are also some I/O functions to make it possible to interact with the user, some shortcut functions and a function for lazy evaluation.Basic principles
As an
esoteric programming language , Unlambda is meant as a demonstration of very pure functional programming rather than for practical use. Its main feature is the lack of conventional operators and data types — the only kind of data in the program are one-parameter functions. Data can nevertheless be simulated with appropriate functions as in thelambda calculus . Multi-parameter functions can be represented with the technique ofcurrying .Unlambda is based around the principle of
abstraction elimination , or the elimination of all saved variables, including functions. As a purely-functional language, not only are Unlambda's functions first-class objects, they are the "only" first-class objects.An implementation of the
hello world program in Unlambda follows:`r```````````.H.e.l.l.o. .w.o.r.l.di
Original built-in functions
The notation
."x"
denotes a function which takes one argument and returns it unchanged, printing the single character "x" as a side effect when it is invoked.i
represents the version of the identity function that has no such side effect; it is used here as a dummy argument. The program`.di
applies thed
-printing function to a dummy argument ofi
, returningi
and printing the letterd
as a side effect. Similarly,``.l.di
first applies.l
to.d
, printing the letterl
and returning.d
; this result of.d
is then applied toi
as in the previous example. The functionr
issyntactic sugar for the function that prints a newline character.Other important features provided by Unlambda include the
k
ands
functions.k
manufactures constant functions: the result of`k"x"
is a function which, when invoked, returns "x". Thus the value of``k"xy"
is "x" for any "x" and "y".s
is a generalized evaluation operator.```s"xyz"
evaluates to``"xz"`"yz"
for any "x", "y", and "z". It is a remarkable fact thats
andk
are sufficient to perform any calculation; see theSKI combinator calculus article for full details. As a brief example, note that the identity functioni
can be implemented as``skk
, since```skk"x"
yields "x" for all "x".Unlambda's one flow control construction is
call with current continuation , denotedc
. When an expression of the form`c"x"
is evaluated, a special "continuation" object is constructed, representing the state of the interpreter at that moment. Then "x" is evaluated, and then the result is given the continuation object as an argument. If the continuation is never applied to an argument, the value of the`c"x"
expression is the same as the value of "x". But if the continuation object is applied to a value "y", execution of "x" is immediately aborted, and the value of the entire`c"x"
expression is "y".Although Unlambda's execution semantics are normally eager, there is a
lazy evaluation option, indicated by the use of thed
operator. Usually, to evaluate an expression of the form`"xy"
, unlambda first evaluates "x", then "y", and then applies "x" to "y". However, if "x" evaluates to the special valued
, then "y" is "not" evaluated; instead, the value of the expression`d"y"
is a special "delayed computation" object, which, when applied to an argument "z", evaluates "y", and then applies its value to "z". Note that in the absence of side effects, this is exactly the same as`i"y"
. The difference is that`i"y"
executes any side effects in "y" immediately, whereas`d"y"
defers the side effects until the result is applied to another argument.Unlambda's next built-in operator is
v
, which ignores its argument and returnsv
. This feature is not strictly necessary, sincev
could be implemented as```s``k``sii``s``s`ksk`k``siik
, but it is supplied as a convenience. (This expression above is simply`Yk
, whereY
denotes afixed point combinator .)Unlambda 2 built-in functions
Additional built-ins were introduced in version 2 of the Unlambda language. Input in Unlambda is facilitated by operators
@
and?"u"
. When@
is applied to a function "x", a character is read from input, and stored as the "current character"; then "x" is applied toi
. However, if no more characters were available on input, the "current character" is left undefined, and "x" is applied tov
instead. When a function?"u"
is applied to a function "x", the result is the evaluation of`"x"i
if the current character is "u", otherwise`"x"v
is evaluated.There is also a "reprint" operator
|
. When`|"x"
is evaluated, the function "x" is applied to."u"
if "u" is the current character, or tov
if there is no current character.Finally, there is an exit operator
e
. Whene
is applied to "x", the execution of the program is terminated, and "x" is taken as the result of the program (most of the currently existing interpreters ignore the result anyway).ee also
Similar languages:
*Iota and Jot
*JoyExternal links
* [http://www.madore.org/~david/programs/unlambda/ Unlambda homepage]
Wikimedia Foundation. 2010.