
A Lisp interpreter in TypeScript - suzuki
http://www.oki-osk.jp/esc/typescript/lisp-en.html
======
suzuki
The Lisp in 1,200 lines of Dart, which has macros, quasi-quotation and tail-
call optimization
([https://news.ycombinator.com/item?id=9903332](https://news.ycombinator.com/item?id=9903332)),
was translated into 1,390 lines of TypeScript. It runs on browsers.

------
hydandata
If you are interested in the future of Lisp in the context of browsers or
Nodejs, take a look at this: [http://lispblog.xach.com/post/138667931963/lisp-
and-webassem...](http://lispblog.xach.com/post/138667931963/lisp-and-
webassembly)

------
eatonphil
Why does the foldl function use a while loop?

~~~
junke
Why not? map, fold/reduce are not necessarily implemented as the textbook
says.

~~~
suzuki
Certainly not. The foldl is a part of the TypeScript program that implements
the Lisp.

By the way, as for "while" in the implemented Lisp, it is defined with
recursion and will be executed with tail-call optimization. See

    
    
      (defmacro while (test &rest body)
        (let ((loop (gensym)))
          `(letrec ((,loop (lambda () (cond (,test ,@body (,loop))))))
             (,loop))))
    

in the const prelude of lisp.ts ([http://www.oki-
osk.jp/esc/typescript/lisp/lisp.ts.html](http://www.oki-
osk.jp/esc/typescript/lisp/lisp.ts.html)).

~~~
junke
Thanks for this information.

My point was more that map and reduce do not inherently _require_ a recursive
implementation and can be implemented directly as loops.

I don't follow closely TypeScript: is tail-call merging done when compiling to
Javascript or is the Javascript runtime responsible for this behavior?

~~~
suzuki
No, neither. That behavior is implemented in the same way as in the Lisp in
Dart ([http://www.oki-osk.jp/esc/dart/lisp-en.html#4](http://www.oki-
osk.jp/esc/dart/lisp-en.html#4)).

------
agumonkey
I will now write all my comment in Kanjis. It's too beautiful.

------
lomnakkus
Thus, yet again, sort-of-validating Greenspun's 10th Rule.

I'm not _complaining_... just _observing_ :).

~~~
jewbacca
As much as I love a good Greenspun invocation, I don't think this really
counts:

> Any sufficiently complicated C or Fortran program contains an ad hoc,
> informally-specified, bug-ridden, slow implementation of half of Common
> Lisp.

isn't about the inevitability of literally implementing a Lisp interpreter.

It's about something more abstract. see: [http://c2.com/cgi-
bin/wiki?LevelsOfGreenspunning](http://c2.com/cgi-
bin/wiki?LevelsOfGreenspunning)

~~~
DonHopkins
It's still got a good shot at validating Zawinski's Law of Software
Envelopment.

> Every program attempts to expand until it can read mail. Those programs
> which cannot so expand are replaced by ones which can.

