Lisp in 32 lines of Ruby

http://blog.fogus.me/2012/01/25/lisp-in-40-lines-of-ruby/

by johndcook • 15 years ago

194 53 15 years ago

blog.fogus.me

kruhft3• 15 years ago

A real lisp: http://sbcl.org

ben0x539• 15 years ago

Next up, lisp in 1 line of common lisp

kruhft3• 15 years ago

#'eval

kruhft3• 15 years ago

I was a bit hasty, here is the complete version:

  (loop (print (eval (read))))

mrspeaker• 15 years ago

I think that's a testament to the awesomeness of Lisp, not of Ruby ;)

bwarp4• 15 years ago

Exactly. I reckon you couldn't invert the process i.e. write Ruby in 32 (short) lines of lisp.

phillmv• 15 years ago

Well. Obviously. The syntax is much, much more complicated.

But if you were to adopt a ruby syntax subset, enough of the semantics are similar enough to not pose a significant problem.

How easy is lisp to implement in a language without first class functions?

ken• 15 years ago

Why not? [:eq, 42, :a] isn't native syntax in any Lisp I've ever seen. This is Lisp-like data structures and evaluation of native Ruby types, not a whole Lisp compiler or even the reader. It doesn't seem like it'd be any harder to get Ruby-like data structures and evaluation of native Lisp types. What's the core of Ruby? class, def, and :send, perhaps? SICP 3.1.1 does pretty much just that.

SoftwareMaven• 15 years ago

I spent a term in college writing a Pascal interpreter in Scheme. It was far more than 32 lines. I wish I still had that code, but, alas, no github in the first half of the nineties.

haberman2• 14 years ago

By that argument BrainFuck is even awesomer than Lisp.

danssig2• 14 years ago

No because after making an interpreter you have a nice language to work with. That makes it very different than BF.

lloeki• 15 years ago

A similar endeavor in Python: http://www.brool.com/index.php/the-tiniest-lisp-in-python

I find it quite entertaining to see how specific language features allow for differing patterns. It is much more apparent with such Lisp implementations than with your typical Hello, World app or hidden by some library or framework.

pangram• 14 years ago

I got a lot of interesting comments from that article. Someone pointed me to this brilliantly evil implementation which can be seen at https://gist.github.com/1679908 (originally from http://www.pick.ucam.org/~ptc24/yvfc.html, which seems to be down). There's also Norvig's implementation, which is much cleaner, at http://norvig.com/lispy.html, and a Lisp to Python compiler at http://bernhardkausler.wordpress.com/2009/11/28/sinc-%e2%80%....

ct_elegans• 15 years ago

I personally, have been waiting centuries for our robotic overlords to improve the runtime performance of lisp. Now I can wait some more!

bwarp4• 15 years ago

Racket and SBCL are very fast.

tikhonj• 15 years ago

Check out the Stalin Scheme[1] compiler which can produce code faster than hand-written C (it's a whole-program optimizing compiler targetting C).

[1] http://en.wikipedia.org/wiki/Stalin_(Scheme_implementation)

pabloPXL3• 14 years ago

Nice, but wasn't chicken scheme the flagship of scheme-to-c compilers? http://www.call-cc.org/

jlongster2• 15 years ago

I've just started working on full-featured Lisp in javascript over the past few weeks: https://github.com/jlongster/outlet

It will compile to js and lua, and I'm focusing on writing games with it. I can attest that writing a Lisp compiler is really fun and shockingly simple in some places.

Current features I'm working on: http://jlongster.com/2012/01/16/outlet-gets-a-personality.ht...

eschulte3• 15 years ago

It may be worthwhile looking at Shen (a similar lisp-like langauge) which targets translation to JS. I haven't checked in on their progress in a while, but it seems the largest implementation hurdle is tail recursion.

shen is http://www.shenlanguage.org/

swannodette• 15 years ago

And of you course you can't talk about compile-to-JS lisps these days without mentioning ClojureScript ;)

pabloPXL3• 14 years ago

It looks really interesting!

marijn• 15 years ago

He seems to have forgotten lambda, without which you can't really write anything more interesting than the examples that are given.

mapgrep• 15 years ago

I thought this was his example of lambda:

  l.eval [:label, :second, [:quote, [:lambda, [:x], [:car, [:cdr, :x]]]]]

No?

indspenceable• 14 years ago

Can someone explain how this works?

I understand that (label second '(...)) makes second evaluate to that in the future, statefully, but, the lambda symbol doesn't even appear to have a definition; furthermore, if you try to use it in a way that would work with a real lambda, it doesn't work.

For instance [[:lambda, [:x], :x], 2]

fogus2• 15 years ago

Even the example using lambda?

sinamdar• 15 years ago

Shameless Self Promotion. Here are two version of the LISP interpreter in JavaScript that I wrote:

1. Direct port of Peter Norvig's version in Python:

https://bitbucket.org/sainamdar/lisp2js/

2. Separate Syntactic Analysis from Execution:

https://bitbucket.org/sainamdar/lisp2js2/

judofyr• 15 years ago

See also: Heist, a feature-rich implementation of Scheme in Ruby: https://github.com/jcoglan/heist

nick_a• 15 years ago

Hey guys

This seems like it would be perfect stuff for an educational lightning talk

If any of you are in the SF Bay Area, please consider doing a ~5 min presentation on your lisp-in-x implementation at the lisp meetup "revival" this saturday at the blackbox mansion in Atherton

...free beer... ;-)

http://www.meetup.com/balisp/events/48872022/ http://balisp.org/

lisper• 15 years ago

Lisp (including full lexical closures) in 50 lines of Python:

http://www.flownet.com/ron/lisp/l.py

eschulte3• 15 years ago

Cute, but from like 28 [1] it looks like there is no macro support, so this isn't a lisp but is rather a way to write a ruby expression in a ruby array.

[1] https://github.com/fogus/ulithp/blob/master/lithp.rb#L28

fogus2• 15 years ago

If macros are needed for the definition of a lisp, then you'll eliminate some important Lisps.[1] If you want macros in the one at the link (ulithp), then you only need to write that feature into an evaluator (dare I say, meta-circular) written in ulithp much like what is done in my other Lisp Lithp.[2]

[1] http://www-formal.stanford.edu/jmc/recursive/recursive.html

[2] https://github.com/fogus/lithp/blob/master/src/core.lisp#L10...

eschulte3• 14 years ago

Link [2] looks very nice and IMO would be a much more interesting topic than the trivial ruby implementation.

I apologize for the dismissive rudeness of my first comment... I am tired of the many "I saved a function and its arguments into a list, and then wrote a method to evaluate that list" implementations which seem to be so exciting. Although I guess this isn't a new trend (see lisp in awk [1]).

[1] http://chasen.org/~daiti-m/etc/awk/walk.pdf

pjscott2• 15 years ago

This "lisp in x lines of y" tradition started with the original Lisp paper back in 1960, which defined lisp in a few lines of lisp. Which, when you think about it, is an extraordinarily lispy thing to do.

LearnYouALisp• 14 years ago

Lambdas all the way down. Now beat that, modern "bootstrapped" compilers.

etrain• 14 years ago

"Look, it's all lambdas all the way down. Until you reach turtles."

pjscott2• 14 years ago

Lisp had to be bootstrapped with another compiler before it could run, of course. The compiler, in this case, was Steve Russell's brain.

http://www-formal.stanford.edu/jmc/history/lisp/node3.html

nodemaker• 15 years ago

Wow...for me learning LISP just earned itself priority-High status!

pabloPXL3• 14 years ago

I translated it to js -> https://gist.github.com/1679611 Earned 1 line, and packed it with a cheap implementation of zip :3

skrebbel• 14 years ago

    :if    => lambda { |(cond, thn, els), ctx| eval(cond, ctx) ? eval(thn, ctx) : eval(els, ctx) },

Seriously, any production code like that (very long line, cryptic variable names to make it fit better on said line) would get nasty review comments here.

Why not put the whole thing a single line and have an even prettier page title?

gaius• 14 years ago

32 lines of Ruby and a hundred thousand lines of C, let's not forget. Anyone can write any short program in a DSL, that is not represenative of the true complexity of it.

quadhome• 14 years ago

And another order of magnitude in assembly.

lignuist• 14 years ago

It seems funny to me, that it needs most probably more lines to write a good lisp tutorial for beginners, than a lisp implementation. Lisps beauty lies in its simplicity.

Lisp in 32 lines of Ruby

Related Stories