Curious. It implies tail call elimination (the description of exhausting the stack explicitly says it wasn't a tail recursive call), but the description sounds like it's so direct that I can't see how it works.

Looking at evalExpr - http://github.com/bobappleyard/golisp/blob/master/lisp/lisp.... - the only way I can see for this to have tail call elimination is if Go itself does (and I don't think it does, does it? It does have coroutines, which you could use to implement trampolining, but I don't see that here...)

I think tail call elimination is handled in the Apply method for closures - http://github.com/bobappleyard/golisp/blob/master/lisp/lisp.... . Looks like a trampoline to me.

I wrote a quip awhile back about wanting a scripting language closely integrated with Go. Maybe this would fit the bill? (Though one with a Go-like syntax would be better.)

That somewhat points to a development environment that I would like---a statically compiled language that is also easily interpreted. You develop with the interpreted version to get the quickest turnaround, and then you compile it for speed when you're ready to release your product.

Seems like LLVM or the JVM would both make this comfortable.

One that can compile its Lisp programs into Go.