anchor.diff:  		       (with-unique-names (ret)
   			 `(progn
   			    (checkpoint ,ctx)
  -			    (let ((,ret ,(compile-expr (cadr form))))
  +			    (let ((,ret
  +				   (handler-case ,(compile-expr (cadr form))
  +				     (parser-return (data)
  +				       (let ((value (parser-return-value data)))
  +					 (if value
  +					     (commit ,ctx)
  +					     (rollback ,ctx))
  +				       (signal 'parser-return :value value))))))
   			      (if ,ret
   				  (commit ,ctx)
   				  (rollback ,ctx))
  
positive.code: (defmacro defrule (name (&rest args) (&optional attachment) &body body)
    (with-unique-names (ctx)
      `(defun ,name (,ctx ,@args)
         ,(if attachment
  	    `(let ((,attachment (parser-context-attachment ,ctx)))
  	       (block rule-block
  		 ,(compile-grammar ctx `(:checkpoint (:and ,@body)))))
  	    `(block rule-block
  	       ,(compile-grammar ctx `(:checkpoint (:and ,@body))))))))
  
  (defmacro defrenderer (name (&rest args) (&optional attachment) &body body)
    (with-unique-names (ctx)
  
negative.code: 
  (declaim (inline checkpoint))
  (defun checkpoint (ctx)
    (push (parser-context-cursor ctx) (parser-context-checkpoints ctx)))
  
  (declaim (inline rollback))
  (defun rollback (ctx)
    (setf (parser-context-cursor ctx) (pop (parser-context-checkpoints ctx))))
  
  (declaim (inline commit))
  (defun commit (ctx)
    (pop (parser-context-checkpoints ctx)))
  
  
  ;;; Atom, Rule & Type Matching
  