anchor.diff:                                            (char string index)
                                           (incf index)))))
                              args))
  -        (:peek-char (apply (lambda (peek-type stream &optional (eof-error-p t) eof-value recursive-p)
  +        (:peek-char (apply (lambda (peek-type stream eof-error-p eof-value recursive-p)
                                (declare (ignore stream recursive-p))
                                (when peek-type
                                  ;; TODO: support peek type
  
positive.code:   (funcall stream :read-char stream eof-error-p eof-value recursive-p))
  
  (defun unread-char (character &optional (stream *standard-input*))
    ;; TODO: implement me!
    (error "implement me!"))
  
  (defun peek-char (&optional peek-type (stream *standard-input*) (eof-error-p t) eof-value recursive-p)
    (funcall stream :peek-char peek-type stream eof-error-p eof-value recursive-p))
  
negative.code:         (index 0))
      (lambda (op &rest args)
        (case op
          (:unread-char (apply (lambda (character stream)
                                 (declare (ignore character stream))
                                 (decf index)
                                 nil)
                               args))
          (:read-char (apply (lambda (stream eof-error-p eof-value recursive-p)
                               (declare (ignore stream recursive-p))
                               (cond ((>= index length)
                                      (if eof-error-p
  