Hacker News Board Hacker News, browsed like a classic message board
Live data from Hacker News

Little Lisp interpreter

hackerschool.com

Post reply on HN
Print view View original

21–30 of 49 posts

Re: Little Lisp interpreter

#21

Post by dugmartin »

The tokenizer breaks on strings with parens in them. You should be able to split on each character and implement a simple variant on the shunting yard algorithm in only a few more lines of code and get a robust tokenizer.

Re: Little Lisp interpreter

#22

Post by nicholasjbs »

cabalamat wrote: post #10

Is there some reason why every code segment inside not one but two scrolling frames? And does anyone else dislike web design that (1) limits the text to a column a third of the page wide, and then (2) because this is too small, requires a horizontal scrollbar on code segments? For an explanation of a small Lisp interpreter (in Python) that uses sane web design, one might consider Norvig's http://norvig.com/lispy.html

Thanks for pointing that out. The double-scrollbar was a CSS bug which was only showing up in some browsers. It should be fixed now.

I agree this page should be wider for posts like this.

Re: Little Lisp interpreter

#23

Post by pmelendez »

ncarroll wrote: post #11

Who needs a toy lisp? Can't we just lisp for real? Edit: Ok, ok. Now that the title of submission has been changed from "Toy Lisp Interpreter" to "Little Lisp Interpreter" my quip, having lost context doesn't make me smile anymore either.

As a learning experience is excellent. Lisp family languages are great for this since they are turing complete and with a pretty simple syntax.

Re: Little Lisp interpreter

#25

Post by brudgers »

pmelendez wrote: post #23
ncarroll wrote: post #11

Who needs a toy lisp? Can't we just lisp for real? Edit: Ok, ok. Now that the title of submission has been changed from "Toy Lisp Interpreter" to "Little Lisp Interpreter" my quip, having lost context doesn't make me smile anymore either.

As a learning experience is excellent. Lisp family languages are great for this since they are turing complete and with a pretty simple syntax.

Under the aesthetics of logic, I find Lisp's syntax pretty as well.

Re: Little Lisp interpreter

#28

Post by hga »

jws wrote: post #18

I think more useful for me would be "How to build a complex system and not accidentally write a toy Lisp interpreter".

"Write it in a Lisp" or "Use a Lisp as an extension language" don't work?

(Last time I tried the latter the more vocal members of the user base complained so much the entire effort died. That was in 2000.)

Re: Little Lisp interpreter

#29

Post by stiff »

Writing a Lisp interpreter is an opportunity to write a really beautiful program, do not waste it by stopping at a first version that sort of works. A nice implementation should read almost like a spec of the language, except maybe for the more prosaic parsing part. Look at the Norvig article, or at the implementation of Ian Piumarta for inspiration:

http://piumarta.com/software/lysp/lysp-1.1/lysp.c

Re: Little Lisp interpreter

#30

Post by breckinloggins »

I wrote one in erlang that works pretty well and is even designed to be able to call into erlang functions (if I took it that far).

https://github.com/breckinloggins/erlisp

I'm currently working on writing one in Haskell using the Scheme48 tutorial [1], though I'd eventually like to replace the evaluator with an F-Algebra[2] so I can learn about that.

https://github.com/breckinloggins/scheme48

As a side note, would any Haskellers be willing to look at the abstraction I did for parsing #-forms? I created an adhoc data structure:

    hashLiteralInfo = [
        ('f', (Nothing, \_ -> Bool False)),
        ('t', (Nothing, \_ -> Bool True)),
        ('b', (Just $ many $ oneOf "01", Number . toInteger . fromBase 2)),
        ('o', (Just $ many $ oneOf "01234567", Number . toInteger . fromBase 8)),
        ('d', (Just $ many $ oneOf "0123456789", Number . toInteger . fromBase 10)),
        ('h', (Just $ many $ oneOf "0123456789abcdefABCDEF", Number . toInteger . fromBase 16))
	]
And then the parser consumes that:

    parseHashLiteral :: Parser LispVal
    parseHashLiteral = do
        char '#'
            c  fail "Internal parse error: unregistered literal info"
                Just (Nothing, f) -> return $ f "unneeded" -- I know there's a more idiomatic way to do that
                Just (Just literalParser, f) -> do
                    digits
This works and is "abstracted", but doesn't feel idiomatic. Thoughts?

[1] http://en.wikibooks.org/wiki/Write_Yourself_a_Scheme_in_48_H...

[2] http://bartoszmilewski.com/2013/06/10/understanding-f-algebr...

Post reply on HN