anchor.diff:        nil
         (cons (car lst) (take (1- n) (cdr lst)))))
   
  +(defun drop (n lst)
  +  (if (= n 0)
  +      lst
  +      (drop (1- n) (cdr lst))))
  +
  +(defun droplast (n lst)
  +  (take (- (length lst) n) lst))
  +
  +(defun index-list (n f)
  +  (if (= n 0)
  +      nil
  +      (cons (funcall f n) (index-list (1- n) f))))
  +
  +(defun group (n lst)
  +  (cond ((null lst) nil)
  +        ((null (nth n lst))
  +         (list lst))
  +        (t (cons (take n lst)
  +                 (group n (drop n lst))))))
  +
  +(defun break-at (v)
  +  (break)
  +  v)
  +
   ;; impl
  -
  +;;; (lambda arg body)
  +;;; (let var1 val1 var2 val2 body)
   (defun rl-eval (exp env)
     (thunk
       (cond ((symbolp exp) (force (lookup exp env)))
  
positive.code:         (t (lookup var (cdr env)))))
  
  (defun bind (var exp env)
      (cons (cons var exp) env))
  
  (defun rl-apply (f x)
    (let ((f (force f)))
      (if (functionp f)
          (funcall f x)
          (force
           (rl-eval (cadddr f)
                    (bind (caddr f) x (cadr f)))))))
  
  (defun normalize-call (fc)
    (reduce (lambda (x acc) (list x acc)) (cddr fc) :initial-value (take 2 fc)))
  
  (defparameter *default-env*
    (mapcar (lambda (k) (cons (car k) (thunk (cdr k))))
            `((t . t)
              (nil . nil)
              (+ . ,(lambda (x) (lambda (y) (+ (force x) (force y)))))
              (if . ,(lambdas (test tr fl)
                              (if (force test)
  
negative.code:            (case (car exp)
               ((quote) (cadr exp))
               ((lambda) `(&proc ,env ,(cadr exp) ,(caddr exp)))
               ((let) (force
                       (rl-eval (car (last exp))
                                (let-bind (droplast 1 (cdr exp)) env))))
               (t (let ((exp1 (normalize-call exp)))
                    (rl-apply (rl-eval (car exp1) env)
                              (rl-eval (cadr exp1) env)))))))))
  