krig / lisp

Lisp interpreter in less than 500 lines of C, including a copying garbage collector and an implementation of LISP 1.5 from 1962.

komplott

A tribute to:

Recursive Functions of Symbolic Expressions and Their Computation by Machine, Part I

(as found in paper/recursive.pdf)

A micro-subset of scheme / the original LISP in a single C file: komplott.c

Features

• Single file implementation.
• Scheme-compliant enough for the test programs to be executable by GNU Guile.
• Copying garbage collector based on Cheney's Algorithm.
• Limited tail call optimization (not true TCO; see tests/true-tco.scm).
• Near-zero error handling.
• Zero thread safety or security.

Also includes:

lisp15.scm

An implementation of the core of LISP 1.5 from 1962

Instructions

• To build the komplott executable, run make. The only dependency aside from make is gcc.

• To run the LISP 1.5 interpreter and a couple of test cases, run make lisp15.

LISP 1.5

The version presented in the README is slightly tweaked from the one that can be found in tests/lisp15.scm in order to more closely resemble early LISP rather than scheme: #t and #f are written as t and nil.

(define pairlis (lambda (x y a)
                  (cond ((null? x) a)
                        (t (cons (cons (car x) (car y))
                                 (pairlis (cdr x) (cdr y) a))))))

(define assoc (lambda (x a)
                (cond ((equal? (caar a) x) (car a))
                      (t (assoc x (cdr a))))))

(define atom? (lambda (x)
                (cond
                 ((null? x) t)
                 ((atom? x) t)
                 (t nil))))

(define evcon (lambda (c a)
                (cond
                 ((eval (caar c) a) (eval (cadar c) a))
                 (t (evcon (cdr c) a)))))

(define evlis (lambda (m a)
                (cond
                 ((null? m) nil)
                 (t (cons (eval (car m) a)
                             (evlis (cdr m) a))))))

(define apply (lambda (fun x a)
                (cond
                 ((atom? fun)
                  (cond
                   ((equal? fun (quote CAR)) (caar x))
                   ((equal? fun (quote CDR)) (cdar x))
                   ((equal? fun (quote CONS)) (cons (car x) (cadr x)))
                   ((equal? fun (quote ATOM)) (atom? (car x)))
                   ((equal? fun (quote EQ)) (equal? (car x) (cadr x)))
                   (t (apply (eval fun a) x a))))

                 ((equal? (car fun) (quote LAMBDA))
                  (eval (caddr fun) (pairlis (cadr fun) x a)))

                 ((equal? (car fun) (quote LABEL))
                  (apply
                   (caddr fun)
                   x
                   (cons
                    (cons (cadr fun) (caddr fun))
                    a))))))

(define eval (lambda (e a)
               (cond
                ((atom? e) (cdr (assoc e a)))
                ((atom? (car e))
                 (cond
                  ((equal? (car e) (quote QUOTE)) (cadr e))
                  ((equal? (car e) (quote COND)) (evcon (cdr e) a))
                  (t (apply (car e) (evlis (cdr e) a) a))))
                (t (apply (car e) (evlis (cdr e) a) a)))))

(define evalquote (lambda (fn x) (apply fn x (quote ()))))

Here is an example of actual LISP 1.5 code:

((LABEL MAPCAR
        (LAMBDA (FN SEQ)
                (COND
                  ((EQ NIL SEQ) NIL)
                  (T (CONS (FN (CAR SEQ))
                           (MAPCAR FN (CDR SEQ)))))))
 DUP LST)

; where
; DUP -> (LAMBDA (X) (CONS X X))
; LST -> (A B C)

To prevent reading from continuing indefinitely, each packet should end with STOP followed by a large number of right parentheses. An unpaired right parenthesis will cause a read error and terminate reading.

STOP )))))))))))))))))

lisp's Issues

Not an issue

Hello,

I have discovered your work through a presentation that was broadcasted on Youtube (from 2019, if I reckon). I have been quite surprised that people would also be interested in developing Lisp interpreters. I have downloaded and tested your interpreter and as a matter of reciprocity, I wanted to share my own interpretation of what Lisp could be:

https://github.com/naver/lispe/wiki

I have put a lot of effort in implementing some important concept from Haskell, which I wanted to play with, closer to the metal, so to say: https://github.com/naver/lispe/wiki/6.9-Retrofitting-Haskell-into-Lisp.

The interpreter also contains a full-fledge terminal editor, with mouse control, which might interest you.

I hope you won't mind that I used this place to interact with you.

Claude Roux
[email protected]

Readme incomplete

I noticed half of the eval function is missing in the README.md

Bignum

I am definitely splitting hairs here, but technically, the arithmetic functions do not use bignums (as the nums are converted into longs for the operations and then back into nums), which slightly defeats the purpose. I understand why that is the case, but I would add it at least as an option.

List creation with lambda (a . b) (cons a b)

Hello,
To create a list, a common method is:
(define list (lambda (x . y) (cons x y)))
=> (list 2 3 4) -> (2 3 4)
However, komplot generates:
-> (2)
I tried to find a solution (near line 130 in komplott.c), but I did'nt come very far.
I have been playing with koplott, extended it with mutable strings and vectors etc. But this issue still is a problem.

Kind regards,
Wouter Boeke