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

[1] http://www.drdobbs.com/open-source/lua-an-extensible-embedde...

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

    ((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).

Plug 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."

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?

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

Alex Shinn's Chibi scheme, weighing in at 50kB (but with a dependency on the Boehm garbage collector, which weighs >1 Mb ...), might fit the bill.

Some links

1. Andy Wingo (main Guile implemetor)'s "buyer's guide" to Scheme implementations - http://wingolog.org/archives/2013/01/07/an-opinionated-guide...

2. Chibi Scheme homepage - http://synthcode.com/scheme/chibi/

ChibiScheme (https://code.google.com/p/chibi-scheme/) tries to be that. I've considered using it but have avoided it due to its relative newness and a few portability issues.

Lysp (http://piumarta.com/software/lysp/) is fairly close to what I'm guessing you're "pining" for and if not, hey it's open source so have at it!

Lysp uses a lot of non-standard (and rarely implemented) extensions, and so would be very hard to use in most places.

The author's own Maru (http://piumarta.com/software/maru/) might be better suited for this, but I'm not sure..

There's also Chicken Scheme.

While maybe not as tiny as Lua, it is designed to be embeddable out of the box.

The FFI is very simple.

Guile?

http://www.gnu.org/software/guile/

Unfortunately, Guile is both larger, and less portable than Lua. It's also licensed under the LGPL, which is harder (or impossible) to use in some environments than Lua's MIT-like license.