/lispy

One can make all kinds of Lisps using simple household items. If one were so inclined.

Primary LanguageCOtherNOASSERTION

Lispy

“One can make all kinds of Lisps using simple household items. If one were so inclined.”

A tiny Lisp(ish) interpreter based on @orangeduck's excellent tutorial, with basic support for integers, strings, conditionals, user-defined vars and functions. No macros and TCO yet, but a man can dream...

Setup

Clone the repo and run:

$ make run

If all is well, you'll wind up in a simple REPL:

>>

Hit Ctrl-D to exit.

To clean the build:

$ make clean

Usage

With formalities out of the way, let's take it for a spin.

The outermost sexpr allows parens to be omitted, so these are equivalent:

(+ 1 (* 2 3))  ; => 7
+ 1 (* 2 3)    ; => 7

Quoted expressions are denoted by braces:

(+ 1 2 3)       ; => 6
{+ 1 2 3}       ; => {+ 1 2 3}
eval {+ 1 2 3}  ; => 6

To load a source file:

load "hello.lsp"

To define and call a function:

-> {n} {* 2 n}              ; => a lambda that doubles its arg
(-> {n} {* 2 n}) 5          ; => 10, calling it directly
def {dbl} (-> {n} {* 2 n})  ; => bind symbol to lambda
dbl 5                       ; => 10

A utility library will be loaded by default, providing some common functionality. Let's check out some of that goodness.

Function definition reloaded, now with a friendlier syntax:

defn {dbl n} {* 2 n}
dbl 5  ; => 10

You can slice and dice...

def {array} (range -3 3)
nth 5 array               ; => 2
apply + (but-last array)  ; => -3
split 2 (reverse array)   ; => {{3 2} {1 0 -1 -2 -3}}

filter and query...

all? num? array          ; => 1 (true)
len (filter odd? array)  ; => 4
drop-while neg? array    ; => {0 1 2 3}

map and fold...

sum (map sqr array)  ; => 28

zip array (map (-> {n} {abs (* 2 n)}) array)
; => {{-3 6} {-2 4} {-1 2} {0 0} {1 2} {2 4} {3 6}}

compose and partially apply functions...

(comp dec abs (apply -)) array  ; => 5

defn {add n incr} {+ n incr}
def {++} (add 1)
++ 0  ; => 1

and so on.

Type the name of the function to get its definition printed:

first  ; => (-> {l} {eval (head l)})

and make sure to check the prologue for more goodies.

Thanks for dropping by! o/