Little Lisp interpreter
maryrosecook.com
maryrosecook.com
Then, instead of adding variables, I wrapped most of the functions on a canvas in the env and used it to generate my talk's slides: https://github.com/llimllib/adhocteam.club/blob/master/slide...
Then I let my coworkers graffiti the slides with the same lisp as I gave my talk, as it was an open web server where you submitted them. A tiny demo is left running at https://www.adhocteam.club/ , but I should write it all up.
I find it's better to write it yourself than just have it explained to you. It really doesn't take that long to do, and it's broken into nice chunks of discrete work.
Greenspun 10th rule rules!!
A function invocation. This comprises a list where the first element
is the function and the rest of the elements are the arguments. first
takes one argument, (1 2), and returns 1.
(1 2)
(first (1 2))In this case it seems to actually check if the first element of the list is a function and only treat it as a function call in that case.
The grandparent poster was confused why the syntax (foo (1 2)) can be used to apply FOO to (1 2). As the parent points out, for typical Lisps this would actually give an error; instead, (foo '(1 2)) would be the appropriate syntax to apply FOO to the form (1 2). Indeed, when strictly evaluating (foo '(1 2)), first the arguments are evaluated. Since functions self-evaluate, FOO evaluates to itself, while '(1 2) evaluates to (1 2). Then, FOO is applied to (1 2). This is in complete agreement with what you said and what the specification says.
However, the Lisp interpreter at hand actually self-evaluates lists whose head is not a function. Thus (1 2) self-evaluates and (foo (1 2)) has the same effect as (foo '(1 2)).
No, in Lisp FOO is a name of a function, not a function itself.
Thus FOO evaluates to a function (otherwise it would be an error) in a Lisp-1 like Scheme. In a Lisp-2 like Common Lisp, one would say that the function value of FOO is retrieved.
> Indeed, when strictly evaluating (foo '(1 2)), first the arguments are evaluated
Actually not. In Lisp the first item needs to be looked at first. If it is determined to name a function, then we can evaluate the arguments, of which there is only one in this case.
PS: The second you quoted out of order. If you reread, you will see that I was referring to FOO as the first "argument" (a typo for "element"..).
if (list[0] instanceof Function) {
return list[0].apply(undefined, list.slice(1));
} else {
return list;
}
It's amazing just how difficult that little problem makes everything.
One thing I did notice in this implementation, is the lack of quoting and cons notation. Although, cons is a weird one in the lisp world given it is the only infix operator in the language.