
Wisp: Small-but-featureful embeddable Lisp interpreter written in Haskell - luu
https://github.com/walpurgisriot/wisp
======
tel

        > wisp lives in the ST (optionally IO) monad. separate 
        > interpreters with completely segregated environments can be 
        > run concurrently. wisp has a few IO facilities, but they're 
        > completely sandboxed and can't accidentally affect the host 
        > program or environment.
    

This is wonderful. There's already an embedded R5RS Scheme for Haskell
([http://hackage.haskell.org/package/husk-
scheme](http://hackage.haskell.org/package/husk-scheme)) but it runs
everything in the IO monad. That makes it fairly annoying for sandboxed
embeddings.

~~~
JoshTriplett
Apart from its use of ST rather than IO, I'm curious how else Wisp compares to
Husk. As far as I can tell, despite the name, Wisp appears to be a Lisp-1
(single namespace for functions and variables, no need to call "apply" or
similar on variables referencing functions to call them).

------
dangoor
Not to be confused with Wisp: Homoiconic JS with clojure syntax, s-expressions
and macros: [https://github.com/Gozala/wisp](https://github.com/Gozala/wisp)

~~~
espringe
Or my: [https://github.com/espringe/wisp](https://github.com/espringe/wisp)
(Whitespace lISP) with f-expressions!

~~~
akkartik
You might like my whitespace lisp with f-expressions:
[http://akkartik.name/blog/wart](http://akkartik.name/blog/wart)

------
cowward
Does anyone have any good, language agnostic resources for writing
interpreters (not just for lisp)?

~~~
majika
/r/compilers [1] has some good resources. You can also check its top
submissions [2].

I also recently found Matt Might's Compilers class [3] via a submission here
on HN. It has a lot of language-agnostic resources.

[1]: [http://www.reddit.com/r/compilers](http://www.reddit.com/r/compilers)

[2]:
[http://www.reddit.com/r/compilers/top/](http://www.reddit.com/r/compilers/top/)

[3]:
[http://matt.might.net/teaching/compilers/spring-2013/](http://matt.might.net/teaching/compilers/spring-2013/)

------
ananas
[https://github.com/apsk/hlisp](https://github.com/apsk/hlisp) Another lisp in
haskell

------
sillysaurus2
I pine for a Lisp with the embeddable ease of Lua.

~~~
pygy_
It could be trivially implemented in Lua as a pre-processor. Lua has lambdas,
higher level functions, lexical scope and tail call elimination.

The main problem is that it doesn't have a ternary operator, making
conditional expression problematic to represent (you have to wrap an if
statement in a lambda called on the fly).

For something more fully featured, see [0], it is written in MoonScript (which
itself compiles to Lua), and the parser depends on LPeg, but writing a
S-expression parser is rather easy.

 _Edit:_ There's also lcl [1], which is implemented in C. Written by lhf, one
of the Lua authors. From the test files, it looks very basic.

\--

[0]
[https://github.com/leafo/moonlisp/tree/master/lisp](https://github.com/leafo/moonlisp/tree/master/lisp)

[1] [http://www.drdobbs.com/open-source/lua-an-extensible-
embedde...](http://www.drdobbs.com/open-source/lua-an-extensible-embedded-
language/184410014)

~~~
_mpu
Wrapping an if in a lambda is unlikely to work as expected.

~~~
pygy_

        ((if foo + -) 4 6)
    

Can be compiled to

    
    
        (function()
            if foo then return plus
            else return minus
            end
        end)()(4, 6)
    

It is far too verbose to be used in manually crafted Lua, but acceptable if
you treat it as a compiler target (with the caveat that the lambda creation
will prevent LuaJIT from JITting that piece of code).

~~~
meric
_Plug_ [https://github.com/meric/l2l](https://github.com/meric/l2l)

"A object-oriented, unicode-enabled lisp that compiles to and runs as fast as
Lua. Equipped with macros and compile-time compiler manipulation. Comes with
all built-in Lua functions."

~~~
pygy_
Nice one! I started coding one after writing the above comment.

I have a question regarding your implementation: why do you use `goto`s rather
than `elseif` to compile `(cond)` blocks? For nested blocks?

~~~
meric
Oh I think it it was for the return value of cond.

