anchor.diff:                             (apply ,value values)
                              (error "Incorrect arity.")))))
   
  -(definitial t t)
  -(definitial f *false*)
  -(definitial nil '())
  -(defprimitive cons #'cons 2)
  -(defprimitive car #'car 1)
  -(defprimitive cdr #'cdr 1)
  -(defprimitive rplaca #'rplaca 2)
  -(defprimitive rplacd #'rplacd 2)
  -(defprimitive eq? #'eq 2)
  -(defprimitive eql? #'eql 2)
  -(defprimitive < #'< 2)
  -(defprimitive > #'> 2)
  -(defprimitive = #'= 2)
  +(definitial |t| *true*)
  +(definitial |f| *false*)
  +(definitial |nil| '())
  +(defprimitive |cons| #'cons 2)
  +(defprimitive |car| #'car 1)
  +(defprimitive |cdr| #'cdr 1)
  +(defprimitive |rplaca| #'rplaca 2)
  +(defprimitive |rplacd| #'rplacd 2)
  +(defprimitive |eq?| (lambda (x y) (if (eq x y) *true* *false*)) 2)
  +(defprimitive |eql?| (lambda (x y) (if (eql x y) *true* *false*)) 2)
  +(defprimitive |<| (lambda (x y) (if (< x y) *true* *false*)) 2)
  +(defprimitive |>| (lambda (x y) (if (> x y) *true* *false*)) 2)
  +(defprimitive |=| (lambda (x y) (if (= x y) *true* *false*)) 2)
   
   (defun repl ()
  -  (loop (print (evaluate (read) *global-env*)) (terpri)))
  +  (let ((*readtable* (copy-readtable *readtable*)))
  +    (setf (readtable-case *readtable*) :preserve)
  +    (loop (print (evaluate (progn (princ "> ") (read)) *global-env*)) (terpri))))
   
   (defun eprogn (exps env)
     (when exps
  
positive.code: (cl:in-package :clutter)
  
  (defparameter *secret-unbound-value* (gensym "SECRETLY-UNBOUND-"))
  (defparameter *false* 'f)
  (defparameter *initial-env* ())
  (defparameter *global-env* *initial-env*)
  
  
negative.code:         (symbol (lookup exp env))
          (otherwise (error "Cannot evaluate: ~S" exp)))
        (case (car exp)
          (|quote| (cadr exp))
          (|if| (if (not (eq (evaluate (cadr exp) env) *false*))
                  (evaluate (caddr exp) env)
                  (evaluate (cadddr exp) env)))
          (|do| (eprogn (cdr exp) env))
          (set! (setf (lookup (cadr exp) env)
                      (evaluate (caddr exp) env)))
          (|lambda| (make-function (cadr exp) (cddr exp) env))
          (|apply| (invoke (evaluate (cadr exp) env)
                         (eval-list (caddr exp) env)))
          (otherwise (invoke (evaluate (car exp) env)
                             (eval-list (cdr exp) env))))))
  