anchor.diff: -(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))
   
  
positive.code:              (error "Unexpected character: ~a~%" next-character))
           :finally (return-from nil (nreverse character-buffer)))))
  
  (defun skip-string-literal )
  
  (defun skip-character-while (predicate stream)
    (declare (ignore next-is-valid-predicate))
    (loop for next-character = (next stream) 
       do (cond ((funcall predicate next-character) (pop! stream))
                (t (return-from nil next-character)))))
  
  (defun skip-character (skip-character stream)
    (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-n-characters (n stream)
    (loop for remainder upto (1- n)
       do (pop! stream)
       :finally (next stream)))
  
  ;;; PARSER GENERATOR
  (defmacro deftoken (name &optional &key (from nil) (read nil) (cond #'characterp)
                                       (word nil) (char nil) (drop t) (bans nil)
                                       (mult nil) (deli nil) (after nil))
    (let ((token-function-body
           (cond (from `(cond-dispatch-collector stream ,from))
                 (mult `(collect-token-repeatedly-with (resolve-to-string ,after) ,mult))
                 (read (if bans
                           `(collect-character-while
                             stream #'(lambda (character)
                                        (or (not (member character ,bans))
                                            (error "Invalid character: ~a" (char-name character)))))
                            `(seqv-dispatch-collector stream ,read)))
                 (cond `(collect-character-while stream ,cond))
                 (word `(collect-string-literal stream ,word))
                 (char (if drop
                           `(skip-character ,char)
                           `(collect-character stream ,char)))
                 (t (format t "Unrecognized token description")))))
      `(defun ,name (stream)
         ,token-function-body)))
  
  (defmacro defparser (name &rest tokens)
    (labels ((string-to-symbol (&rest arguments)
  
negative.code: 
  (defun collect-character (stream character)
    (let ((next-character (read-char stream nil)))
      (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)
  