anchor.diff:  This function can be used within the lexcial scope of
   with-call/cc and outside, though it has slightly different
   semantics."
  -  (drive-cps (lambda ()
  -               (let ((k (apply (car k) (cdr k))))
  -                 (cond
  -                   (other-values (apply k primary-value other-values))
  -                   (primary-value-p (funcall k primary-value))
  -                   (t (funcall k nil)))))))
  +  (drive-interpreter/cc
  +   (lambda ()
  +     (let ((k (apply (car k) (cdr k))))
  +       (cond
  +         (other-values (apply k primary-value other-values))
  +         (primary-value-p (funcall k primary-value))
  +         (t (funcall k nil)))))))
   
   ;;;; Implementation
   
  -(defun drive-cps (cps)
  +(defun drive-interpreter/cc (code)
     (catch 'done
  -    (loop for func = cps then (funcall func))))
  +    (loop for thunk = code then (funcall thunk))))
   
   (defmacro let/cc (k &body body)
     `(call/cc (lambda (,k) ,@body)))
  
positive.code:                       `(lambda (,v) (setf ,name ,v))))
                evaluate-env)))
      (setf evaluate-env `(list ,@(nreverse evaluate-env)))
      `(drive-cps (evaluate/cps ,(walk-form (if (rest body)
                                                `(progn ,@body)
                                                (first body))
                                            nil walk-env)
                                ,evaluate-env
                                *toplevel-k*))))
  
  (defun kall (k &optional (primary-value nil primary-value-p)
                 &rest other-values)
  
negative.code:       env))
      
      ((eql 'funcall (operator func))
       (evaluate-funcall/cc (arguments func) env k))
      
      ((eql 'apply (operator func))
       (evaluate-apply/cc (arguments func) '() env k))
      
      ((and (symbolp (operator func))
            (get (operator func) 'defun/cc))
       (evaluate-arguments-then-apply
        (lambda (arguments)
          (apply-lambda/cc (get (operator func) 'defun/cc) arguments k))
        (arguments func) '()
        env))
  
  