anchor.diff:                          ,env
                           ,k)))
         (dolist* ((var . value) evaluated-bindings
  -                (evaluate/cps-progn body env k))
  +                (evaluate-progn/cc body env k))
           (setf env (register env :let var value)))))
   
  -(defmethod evaluate/cps ((let* let*-form) env k)
  -  (evaluate/cps-let* (binds let*) (body let*) env k))
  -
  -(defk k-for-evaluate/cps-let* (var bindings body env k)
  -    (value)
  -  (evaluate/cps-let* bindings body
  +(defmethod evaluate/cc ((let* let*-form) env k)
  +  (evaluate-let*/cc (binds let*) (body let*) env k))
  +
  +(defk k-for-evaluate-let*/cc (var bindings body env k)
  +    (value)
  +  (evaluate-let*/cc bindings body
                        (register env :let var value) k))
   
  -(defun evaluate/cps-let* (bindings body env k)
  +(defun evaluate-let*/cc (bindings body env k)
     (if bindings
         (destructuring-bind (var . initial-value)
             (car bindings)
  -        (evaluate/cps initial-value env
  -                      `(k-for-evaluate/cps-let* ,var ,(cdr bindings) ,body ,env ,k)))
  -      (evaluate/cps-progn body env k)))
  +        (evaluate/cc initial-value env
  +                      `(k-for-evaluate-let*/cc ,var ,(cdr bindings) ,body ,env ,k)))
  +      (evaluate-progn/cc body env k)))
   
   ;;;; IF
   
  -(defk k-for-evaluate/cps-if (then else env k)
  +(defk k-for-evaluate-if/cc (then else env k)
       (value)
     (if value
  -      (evaluate/cps then env k)
  -      (evaluate/cps else env k)))
  -
  -(defmethod evaluate/cps ((if if-form) env k)
  -  (evaluate/cps (consequent if) env
  -                `(k-for-evaluate/cps-if ,(then if) ,(else if) ,env ,k )))
  +      (evaluate/cc then env k)
  +      (evaluate/cc else env k)))
  +
  +(defmethod evaluate/cc ((if if-form) env k)
  +  (evaluate/cc (consequent if) env
  +                `(k-for-evaluate-if/cc ,(then if) ,(else if) ,env ,k )))
   
   ;;;; LOCALLY
   
  -(defmethod evaluate/cps ((locally locally-form) env k)
  -  (evaluate/cps-progn (body locally) env k))
  +(defmethod evaluate/cc ((locally locally-form) env k)
  +  (evaluate-progn/cc (body locally) env k))
   
   ;;;; MACROLET
   
  -(defmethod evaluate/cps ((macrolet macrolet-form) env k)
  -  (evaluate/cps-progn (body macrolet) env k))
  +(defmethod evaluate/cc ((macrolet macrolet-form) env k)
  +  (evaluate-progn/cc (body macrolet) env k))
   
   ;;;; multiple-value-call
   
  
positive.code: 
  (defmacro defun/cc (name arguments &body body)
    `(progn
       (setf (get ',name 'defun/cc) (make-instance 'cps-closure
                                                   :code (walk-form '(lambda ,arguments ,@body) nil nil)
                                                   :env nil))
       (defun ,name ,arguments
  
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)))
  