μLithp - a Lisp in 27 lines of Ruby

http://fogus.github.com/ulithp/

by Peteris • 14 years ago

137 98 14 years ago

fogus.github.com

tzaman3• 14 years ago

Is it normal that I don't have the slightest idea what I'm reading here, or is it just me?

nine_k4• 14 years ago

If you don't know what Lisp is, and are a programmer, it's high time to go read about its basic principles.

Lisp is very simple and very powerful. Those who don't learn it are doomed to reinvent it, badly (cough XSLT cough).

jjtheblunt2• 14 years ago

So true re XSLT etc.

bbx2• 14 years ago

I'm not exactly a programmer. Could you explain how Lisp can be simple and powerful?

voidlogic• 14 years ago

I can't say for sure- but I would guess that it would be normal for a lot of HN articles to go over your head if you are not technical or lack a C-S degree.

tzaman3• 14 years ago

I do lack a C-S degree, however I've been a PHP developer for years and recently switched to Ruby, or more specifically RoR.

wonderzombie7• 14 years ago

http://www.defmacro.org/ramblings/lisp.html

I have been playing with a Clojure, a Lisp dialect, for six or so months (it seems so much longer), but this was still really interesting to me.

bitops• 14 years ago

I think this is a neat project and a nice demonstration of how Lisp-influenced Ruby is.

However, whenever people post "Lisp in Ruby" stories, I always hope that it'll be a "Clojure in Ruby" implementation. I am surprised no-one has done it yet.

pekk• 14 years ago

Apart from using the JVM, what is the advantage of Clojure over other Lisp dialects?

nine_k4• 14 years ago

Javascript as a possible compile target (https://github.com/clojure/clojurescript)?

Optional static typing (a la Qi) is being implemented, too.

mtrimpe• 14 years ago

It's default usage of purely functional data structures and a rich concurrency model (STM, actors and more.)

glogla• 14 years ago

I'm not sure about objective advantages (and note that I'm familiar only with Clojure, Common List and as much Scheme as there is in SICP), but Clojure feel kind of tight to me. In CL, array, hashmap, set and list have completely different interfaces, while in Clojure the interface is not only very similar (and nice, for example vector is also method to access itself), but allow you to use the same code to access different storage types. Clojure also felt more functional than CL. Clojure also felt more comfortable in ways such as distributing code, getting libraries and things like that, it's visible that the world of development tools have moved on since the CL of 1985.

wonderzombie7• 14 years ago

I am mostly familiar with Clojure as opposed to CL (have read a bit of Practical Common Lisp) or Scheme (have read a decent chunk of SICP), but there are some pieces here and there.

Clojure is immutable by default, which is a pretty big difference AIUI. It also has a pretty strong emphasis on concurrency, including a bunch of primitives for such. It uses STM.

A bunch of data structures are first class, like vectors, maps, and sets. There are literals for each of them, and you can use maps and sets as functions. You can also use keywords as functions against maps to e.g. retrieve the :name value from a list of maps:

    user=> (map :name [{:name "foo"} {:name "bar"}])
    ("foo" "bar")

Lambda literals are nice:

    user=> (map #(* 2 (inc %)) [1 2 3])
    (4 6 8)

They can take multiple args (e.g. %1 %2) instead of just %.

Threading macros are somewhat closer to Haskell's syntactically straightforward function composition:

    user=> (->> [1 2 3] ;; this'll be the last arg passed to each fn below
    #_=>   (map #(* 2 %))
    #_=>   (map inc))
    (3 5 7)

I'm sure there's more. Maybe a more experienced Lisper can chime in.

asimjalis2• 14 years ago

Clojure has cleaner syntax and matches the expectations of people used to languages that assume an underlying POSIX-like operating system.

jjtheblunt2• 14 years ago

Why would anyone? Clojure runs on the JVM which supports native os threads, concurrent garbage collection, etc, for one thing. Different tools for different purposes.

jshen2• 14 years ago

The JVM also takes 100MB to startup a Web server. Maybe I want to use less ram?

bentoner• 14 years ago

I always hope that it'll be a "Clojure in Ruby" implementation. I am surprised no-one has done it yet.

They have: http://rouge.io/ https://github.com/rouge-lang/rouge

nine_k4• 14 years ago

1993: «Any sufficiently complicated C or Fortran program contains an ad hoc, informally-specified, bug-ridden, slow implementation of half of Common Lisp.» [1]

20 years later: for Ruby users, situation improves! :)

[1] http://en.wikipedia.org/wiki/Greenspuns_tenth_rule

jrockway• 14 years ago

"Common Lisp" means the loop macro and CLOS, I think. And you guys still don't have those ;)

wonderzombie7• 14 years ago

Don't forget the corollary: https://en.wikipedia.org/wiki/Greenspuns_tenth_rule#Morris.2....

dbyrd• 14 years ago

Cool project, but I think it's been done before in less lines: https://gist.github.com/4176087

fogus8• 14 years ago

That's based on an older version of uLithp that had a couple bugs.

nine_k4• 14 years ago

The linked gist has 40 lines (36 LOC); the article from the post boasts 27 lines.

JasonFruit2• 14 years ago

I've never understood the line-count craze some people get on. If it was that important, we'd all be using J or APL. Since we're not — in fact, almost nobody is — it must not be that critical.

LiveTheDream• 14 years ago

It's just supposed to be fun, challenging, and a learning experience.

stcredzero2• 14 years ago

> If it was that important, we'd all be using J or APL.

Fallacy. You haven't eliminated the possibility that line count is important, but also that too few lines is also bad. It's widely understood that line count, even though it's a hazy and exploitable metric, is indeed important. It's also widely understood that being too terse is as bad as being too verbose. Time to brush up on some old-school CS curriculum books. (Mythical Man-Month? I'm not sure if the above is discussed there, but it's a good place to start.)

hk__2• 14 years ago

You should use Docco for your page, I find it much more readable: http://jashkenas.github.com/docco/

judofyr• 14 years ago

Or, well, Rocco in this case: http://rtomayko.github.com/rocco/

codemac• 14 years ago

Ah, but this is org-mode! He can evaluate his code inside his editor! Grumble rah rah emacs!

He could probably set up his publish templates to accomplish the same formatting.

(huge org mode nerd, checking in)

--- EDIT ---

And what do you know, Eric Schulte already implemented this for org mode! It's checked in under contrib.

Instructions: http://eschulte.me/org-docco/org-docco.html

Org source: http://orgmode.org/w/?p=org-mode.git;a=blob_plain;f=contrib/...

fogus8• 14 years ago

I'm quite familiar with Docco having helped implement something similar for Clojure.[1] I wanted to use org-mode. Sorry it's not readable.

[1] http://github.com/fogus/marginalia

draegtun2• 14 years ago

Above was HN submission from early last year, Lisp in 32 lines of Ruby, which was the original blog post of this code by Fogus.

quarterto• 14 years ago

Yeah, 27 lines. Unless you count the ~120 lines of sexpistol.

https://github.com/aarongough/sexpistol

apl• 14 years ago

Syntactic transformation isn't really what it's about, is it? Parsing S-expressions into some internal representation is easily the most boring component of a working Lisp.

fogus8• 14 years ago

My s-expression reader is 34 lines. https://github.com/fogus/ulithp/blob/master/src/reader.rb

A minimal Lisp (the bare minimal) does not require sexprs though.

gruseom2• 14 years ago

A minimal Lisp (the bare minimal) does not require sexprs

Really? Why not? I realize that McCarthy's original spec used recursion equations, but that notation is more complicated than s-expressions.

krosaen• 14 years ago

related: Norvig's implementation of lisp in python:

http://norvig.com/lispy.html

lispm• 14 years ago

Norvig's implementation of Scheme in Lisp:

http://books.google.de/books?id=QzGuHnDhvZIC&lpg=PA756&#...

draegtun2• 14 years ago

Also a Scheme implementation written in Perl by Bill Hails - Exploring Programming Language Architecture in Perl:

(book & code) - http://billhails.net/Book/ | Previous HN post - http://news.ycombinator.com/item?id=1747132

meric• 14 years ago

plug

Once upon a time I wrote a lisp to lua compiler in 100 lines. https://github.com/meric/l2l/commit/a530f0133e002c3981937d21...

It's now over a thousand. https://github.com/meric/l2l/

dmcdougall_• 14 years ago

My one question is: Why?

albertoavila• 14 years ago

It's weird that this question keeps coming out in several cool but not that useful HN posts.

Some times it's cool to do things just because you can, maybe he was bored or he always wanted to implement a lisp dialect.

It might not be that useful, but i'm sure that the autor had a blast doing it, otherwise he wouldn't have done it.

fogus8• 14 years ago

Why not?

fogus8• 14 years ago

But really the "why" is that it was fun. Also, it was my submission to the PLT Games. http://pltgames.com/competition/2012/12

redler• 14 years ago

To learn.

asimjalis2• 14 years ago

Who’s up for implementing a μRuby on top of this μLisp?

mahmud3• 14 years ago

Before this devolves into another farcical, Lisp arm-chair punditry: at 9 operators it's pretty much a kernel untyped lambda-calculus with pairs. And just that.

The implementation is as trivial as the concept is profound. The discussion should be about the lambda-calculus, not Lisp, which is a far more complex beast. And much less about Lisp dialects, Greenspun's, or the usual BS topics that invariably appear on any L-word thread.

fogus8• 14 years ago

If I had a little more time I would have written the uLithp eval in uLithp. The stark simplicity of that never fails to take my breath away.

mahmud3• 14 years ago

Even then, it should inspire people to study the fundamentals, not go into big-language punditry :-D

ufo• 14 years ago

But will it be dynamically or statically scoped? :)

fogus8• 14 years ago

The fun part that distinguishes an early Lisp from the pure lambda calculus is the mixing of strict evaluation and call-by-need. I had to hack that a bit by making a distinction between Procs created with proc vs those with lambda and by tearing apart function bodies. I forget how the original Lisp made the distinction. It looks like I need to re-re-re-re-re-read the Lisp 1.5 manual.

pi18n• 14 years ago

I thought they just had special rules for expressions with a car in {set!, lambda, if, quote, ...} such that arguments to those are not evaluated. From there you can construct whatever else. I might be mistaken, I'm not clear on the history of it.

You know what you might like, if you haven't seen it yet, is the Kernel programming language, a Scheme where everything, including macros, is first-class.

lopatin2• 14 years ago

Really? Lithp? Not that I'm offended, but the pun seems unnecessary.

pohl• 14 years ago

Is necessity a prerequisite for humor?

lopatin2• 14 years ago

It's not. And it's totally understandable how this could pass for humor in middle school.

sejje2• 14 years ago

I want to learn a lisp variant. I'm okay in several scripting languages--Python, Ruby, PHP.

Any obvious choice? (If not, I imagine I'd like to learn the most widely-used)

steveklabnik2• 14 years ago

> I imagine I'd like to learn the most widely-used

Learn yourself some Clojure for great good.

sejje2• 14 years ago

Light Table implements clojure, right?

Then I can get busy with that ahead of time (I've been sweating a Python release)!

Thank you.

6cxs2hd6• 14 years ago

Racket is another obvious choice.

chimeracoder• 14 years ago

Clojure has its selling points, but if you're learning Lisp for fun or intellectual gain, I'd definitely recommend Racket.

blue1• 14 years ago

Common Lisp is the obvious choice

rrmm• 14 years ago

I love the economy of lisp implementations in dynamic languages. It's especially nice because you don't have to worry about the memory management.

On the otherhand, I've been interested in doing a lisp in low memory environments (uC's, etc). I've done a dialect in C using a semi-space garbage collector. But I'm curious if anyone's done any work on lisps in resource constrained environments.

dschiptsov6• 14 years ago

Don't call it Lisp.

Lisp begins with something like this:

  (defmacro when (test &body forms)
      `(cond (,test nil ,@forms)))

Without using underlying list structure, environments, lexical scoping and reader function it is just a lisp-like syntax.

Lisp without lists at its core is nothing but another clumsy language. Look at Clojure - what a mess.

guard-of-terra• 14 years ago

What's the problem with Clojure?:

    (defmacro when
	  "Evaluates test. If logical true, evaluates body in an implicit do."
	  {:added "1.0"}
	  [test & body]
	  (list 'if test (cons 'do body)))

Moreover, what's the problem with μLithp?

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

    l.eval [:second, [:quote, [1, 2, 3]]]

Seems list-y enough for me. I have a feeling that you didn't actually read the article.

dschiptsov6• 14 years ago

There isn't any problem with this Clojure macro. If you would like to see problems with Clojure, take a look at keep function in core.clj.

There is a classic function:

  (define (filter fn l)
      (cond ((null? l) '())
	  ((fn (car l)) (cons (car l) (filter fn (cdr l))))
	  (else (filter fn (cdr l)))))

The point is that stuffing more data-structures into a lisp ruins it. Somehow switching to the prefix notation and adding parenthesis doesn't transform Java to Lisp.

For the second piece of code - are't semicolons and comas somehow redundant?

Moreover, what is the point of writing something this way?

joethephish• 14 years ago

Not sure what this proves exactly. For fun, here's a Javascript equivalent in 27, err, "lines":

    module.exports = function() {
        var atom = function(val) { return val instanceof Array ? false : true; };
        var env = {
            label:  function(sexpr, senv) { senv[sexpr[1]] = evaluate( sexpr[2] ); },
            quote:  function(sexpr, senv) { return sexpr[1]; },
            "==":   function(sexpr, senv) { return evaluate(sexpr[1], senv) == evaluate(sexpr[2], senv); },
            head:   function(sexpr, senv) { return evaluate(sexpr[1], senv)[0]; },
            tail:   function(sexpr, senv) { return evaluate(sexpr[1], senv).slice(1); },
            conc:   function(sexpr, senv) { return [evaluate(sexpr[1])].concat(evaluate(sexpr[2])); },
            "if":   function(sexpr, senv) { return evaluate(sexpr[1], senv) ? evaluate(sexpr[2], senv) : evaluate(sexpr[3], senv); },
            atom:   function(sexpr, senv) { return atom(sexpr[1]); },
            lambda: function(sexpr, senv) {
                return function(lexpr, lenv) {
                    for(var i=0; i<sexpr[1].length; ++i) lenv[sexpr[1][i]] = evaluate(lexpr[i+1], lenv);
                    return evaluate(sexpr[2], lenv);
                };
            }
        };

        var evaluate = function(sexpr, senv) {
            senv = senv || env;
            if( atom(sexpr) ) return senv[sexpr] !== undefined ? senv[sexpr] : sexpr;
            else return senv[sexpr[0]](sexpr, senv);
        };

        this.evaluate = evaluate;
    };

Example:

    var notlisp = require("./notlisp.js"); 
    var l = new notlisp();
    l.evaluate( ["label", "second", ["lambda", ["x"], ["head", ["tail", "x"]]]] );
    l.evaluate( ["second", ["quote", [1, 2, 3]] ] );

μLithp - a Lisp in 27 lines of Ruby

Related Stories