anchor.diff:                                  (force fl))))
               (error . ,(lambda (x) (error (force x)))))))
   
  +(defun y (f)
  +  ((lambda (x) (funcall f (funcall x x)))
  +   (lambda (y)
  +     (funcall f (lambda (&rest args)
  +                  (apply (funcall y y) args))))))
  +
  +(defun y (f)
  +  (funcall f (y f)))
  +
  +(defun fac (f)
  +  (lambda (n)
  +    (if (zerop n)
  +	1
  +	(* n (funcall f (1- n))))))
  
positive.code:            (case (car exp)
               ((quote) (cadr exp))
               ((lambda) `(&proc ,env ,(cadr exp) ,(caddr exp)))
               (t (let ((exp1 (normalize-call exp)))
                    (rl-apply (rl-eval (car exp1) env)
                              (rl-eval (cadr exp1) env)))))))))
  
negative.code:       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)))
  