anchor.diff:        (kontinue k value)
         (throw 'done value)))
   
  -(defmethod evaluate/cps ((func free-application-form) env k)
  +(defmethod evaluate/cc ((func free-application-form) env k)
     (cond 
       ((eql 'call/cc (operator func))
  -     (evaluate/cps (make-instance 'free-application-form
  +     (evaluate/cc (make-instance 'free-application-form
                                     :operator 'funcall
                                     :arguments (list (first (arguments func)) (make-instance 'constant-form :value k :source k))
                                     :source (source func))
  
positive.code:       env))
      
      ((eql 'funcall (operator func))
       (evaluate/cps-funcall (arguments func) env k))
      
      ((eql 'apply (operator func))
       (evaluate/cps-apply   (arguments func) '() env k))
      
      ((and (symbolp (operator func))
            (get (operator func) 'defun/cc))
       (evaluate-arguments-then-apply
        (lambda (arguments)
          (apply-cps-lambda (get (operator func) 'defun/cc) arguments k))
        (arguments func) '()
        env))
  
  
negative.code: This function can be used within the lexcial scope of
  with-call/cc and outside, though it has slightly different
  semantics."
    (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-interpreter/cc (code)
    (catch 'done
      (loop for thunk = code then (funcall thunk))))
  
  (defmacro let/cc (k &body body)
    `(call/cc (lambda (,k) ,@body)))
  