Page Title

This is a very minimal scheme-inspired lisp interpreter (with tail call optimization!) which likely has many bugs. Currently all functions/keywords are:

lambda
syntax: (lambda (arg1 arg2 ...) code)
purpose: returns a function
function
syntax: (function (functionName arg1 arg2 ...) code)
purpose: binds a function to functionName
named-let
syntax: (named-let functionName ((arg1 val1) (arg2 val2) ...) code)
purpose: define functionName with args arg1, arg2, ... and return the value returned by calling it with the values given for each argument. The function can be called from within itself using the name of the function
if
syntax: (if cond code1 code2)
purpose: if cond is true (true defined as any JS truthy value) then it executes and returns the return value of code1, else it does the same but for code2
print
syntax: (print value)
purpose: prints the given value
<
syntax: (< arg1 arg2)
purpose: returns whether or not arg1 is less than arg2 (uses JS less-than operator)
-
syntax: (- arg1 arg2)
purpose: returns arg1 minus arg2 (uses JS subtraction operator)
*
syntax: (* arg1 arg2)
purpose: returns arg1 multiplied by arg2 (uses JS multiplication operator)

Known problems:

No syntax checking beyond parenthesis matching.
Won't throw an error if you name a variable (a variable being defined as a name with a value bound to it, e.g. a function argument) a number instead of a valid identifier. The variable will simply be inaccessible.
If the lisp takes a while to execute or enters an infinite loop, the JS will hang until the lisp program terminates, which in the case of an infinite loop is never (unless the JS is forcefully stopped, e.g. closing SoloLearn).

I plan to add more functions and other features as well as fix the known problems, but knowing myself I'll probably never get around to doing it.