lisnim - Lisp interpreter in Nim

Inspired by lis.py by Peter Norvig.

This is "just for fun" project. Don't expect much.

Usage

Linux: ./lis [source1 source2 ...]

Windows: .\lis.exe [source1 source2 ...]

Syntax

• Base:

  • (quote ...) or '(...)
  • (list ...)
  • (if test conseq alt)
  • (echo arg) Prints and returns arg

• Functions:

  • (def name value) Binds value to name
  • (def (name args...) body) Defines function name with args. Equivalent of (def name (lambda (args...) body))
  • (fn-name args...) Function application

• Lambdas:

  • (lambda (args...) body) Anomymous function
  • (\ (args...) body) Lambda a la Haskell :) \x -> x + x
  • (fn arg body) Lambda of one argument. Useful for curried functions
  • (fun arg body) Variant of the above for those of us who like to have some fun
  • ((lambda (x y) (+ x y)) 5 6) Lambda application

• Sequential evalueation:

  • (do (expr1) (expr2) ...) Sequential evaluation with results of previous evaluation being saved in local environment. This means that variable i defined in expr1 is visible in all following expressions, but not visible outside of do
  • (begin (expr1) (expr2) ...) Syntactic variant of the above

Types

• List: (item1 item2 ...)
• Number: int, float or ratio e.g. 5, 3.1415926, 42/7
• Bool: T or NIL
• String: "line of characters bound in quotes"

Built-in functions

• Boolean: t, nil
• Type-check: bool?, number?, defined?
• Check: nil?, null?
• Constants: pi, e
• Arithmetics: +, -, *, /, max, min, abs, round, mod, odd?, even?
• Comparison: =, !=, >, <, >=, <=
• List: cons, snoc, car, cdr, len
• Output: echo, print
• Strings: capitalize, upcase, downcase, len, char, format, fmt
• Exit: exit, quit (with optional errorcode)

Example

(def (factorial n) (if (<= n 1) 1 (\* n (factorial (- n 1)))))

(def (map f ls)  (if (nil? ls)
  '()
  (cons (f (car ls)) (map f (cdr ls)))))

(echo (map (fn x (+ x 1)) '(1 2 3 4)))   ; output: ( 2 3 4 5 )

(fn () (+ 5 6))   ; returns anonymous function 'fn ()'
((fn () (+ 5 6))) ; anonymous function application

(def somefun
  (fn x
    (fn y
      (+ x y))))  ; curried function

(somefun)         ; => fn (x) -> fn (y) partial application (though 'fn (y)' not showed)
(somefun 5)       ; => fn (y)  partial application
(somefun 5 6)     ; => 11 fully applied
((somefun 5) 6)   ; same as above
(((somefun) 5) 6) ; same as above
((somefun) 5 6)   ; save as above

Building

To build: nim c lis.nim

To run on Linux:

./lis

./lis filename

To run on Windows:

.\lis.exe

.\lis.exe filename

Embedding:

  import lis

  proc myfunc(args: openarray[Atom]): Atom {.cdecl.} =
    stdout.write "This is my own function! "
    for arg in args:
      stdout.write $arg
    stdout.write "\n"

  setAtom("myfunc", atom myfunc)
  discard execLine("""(myfunc "hello," " world" "!")""")

Notes

• Nested functions ARE now supported.

(def (f x)
  (do
    (def (g x) (+ x 1))
    (g x)))
 ; `g` is visible inside `f`, but not outside