anchor.diff:  
   (defun collect-character (stream character)
     (let ((next-character (read-char stream nil)))
  -    (or (when (char= next-character character) 
  +    (or (when (char= next-character character)
             next-character)
           (error "Unexpected character: ~a~%" next-character))))
  +
  +(defun collect-character* (stream character)
  +  (format t "Will collect all ~a characters from stream ~a~%" character stream))
   
   (defun collect-character-while (stream predicate)
     (loop for current-character = (pop! stream)
  
positive.code: (defun collect-token-repeatedly-with (delimiter stream)
    (loop for current-character = (next stream)
       until (null (next stream))
       collect (collect-character-while stream #'(lambda (character)
                                                   (not (char= character delimiter))))))
  
  (with-input-from-string (s "hello there world")
    (collect-token-repeatedly-with #\space s))
  
  (defun cond-dispatch-collector (stream token-list)
    (format t "Tokens ~a on stream ~a~%"token-list stream))
    
  (defun seqv-dispatch-collector (stream token-list)
    (mapcar #'(lambda (token) (funcall token stream)) token-list))
  
  ;;; PARSING UTILITIES
  (defun next (stream) (peek-char nil stream nil nil))
  
  
negative.code:              (error "Unexpected character: ~a~%" next-character))
           :finally (return-from nil (nreverse character-buffer)))))
  
  (defun collect-string* (stream delimiter)
    (loop for current-character = (next stream)
       until (null (next stream))
       collect (collect-character-while stream #'(lambda (character)
                                                   (not (char= character delimiter))))))
  
  (defun collect-string-while (stream predicate) ())
  
  (defun skip-character (stream skip-character)
    (loop for next-character = (next stream) ;until (null next-character)
       do (if (char= next-character skip-character)
              (pop! stream)
              (return-from nil next-character))))
  
  (defun skip-character* (stream skip-character) ())
  
  (defun skip-character-while (stream predicate)
    (loop for next-character = (next stream)
       do (cond ((funcall predicate next-character) (pop! stream))
                (t (return-from nil next-character)))))
  
  
  (defun skip-n-characters (stream n)
    (loop for remainder upto (1- n)
       do (pop! stream)
       :finally (next stream)))
  
  ;;; PARSER GENERATOR
  (defun sequentially-resolve-tokens (stream token-list)
    (mapcar #'(lambda (token) (funcall token stream)) token-list))
  
  (defun conditionally-resolve-tokens (stream token-list)
    (format t "Conditionally choose from ~a for ~a~%" token-list stream))
  
  (defun repeat-resolve-tokens (stream token-list)
    (format t "repeat-resolve-tokens ~a ~a." stream token-list))
  
  (defun resolve-banlist (directives)
    (format t "A list of characters is returned from ~a~%" directives))
  
  (defmacro defparser (name &rest tokens)
    (labels ((string-to-symbol (&rest arguments)
  