Lambda Evaluator
----------------
There is now a [lambda evaluator](http://lambda.jimpryor.net/lambda-let.html) available.
It will allow you to write lambda terms and evaluate them, with full ability to inspect the results.
(This won't work in Racket, because Racket doesn't even try to represent the internal structure of a function in a human-readable way.)
*Lambda terms*: lambda terms are written with a backslash, thus: `((\x (\y x)) z)`.
If you click "Reduce", the system will produce a lambda term that is guaranteed to be reduction equivalent (`<~~>`) with the original term. So `((\x (\y x)) z)` reduces to (a lambda term equivalent to) `(\y z)`.
*Let*: in order to make building a more elaborate set of terms easier, it is possible to define values using `let`.
In this toy system, `let`s should only be used at the beginning of a file. If we have, for intance,
let true = (\x (\y x)) in
let false = (\x (\y y)) in
((true yes) no)
the result is `yes`. Things to watch out for: the expression after the equal sign must have balanced parentheses,
and the "in" is obligatory. If you violate these rules, the system will still produce a result, but it won't make much sense.
*Abbreviations*: No abbreviations work. So `\xy.yxx` must be written `(\x (\y ((y x) x)))`.
*Comments*: anything following a semicolon to the end of the line is ignored.
Blank lines are fine.
Under the hood
---------------
The interpreter is written in JavaScript (which is not closely related to Java), and runs inside your browser.
So if you decide to reduce a term that does not terminate (such as `((\x (x x)) (\x (x x)))`), it will be your
browser that stops responding, not the wiki server.
You can inspect the code [here](http://lambda.jimpryor.net/code/lambda.js). Suggestions for improvements welcome.
Improvements we hope to add soon: the ability to reduce Combinatory Logic combinators; the ability to translate from CL to the lambda calculus; and more sensible variable names instead of `g354`.