anchor.diff:           (with-input-from-string (input-stream input-string)
              (value input-stream))))))
   
  -;;; JSON GRAMMAR
  -(defparser json
  -  (value           :from (array-block object-block numeric-value boolean-value null-value string-literal value))
  -  (boolean-value   :from (boolean-true boolean-false))
  -  (quotes          :from (single-quotes double-quotes))
  -  (spaces          :from (whitespace newline))
  -
  -  (array-block     :mult (value)     :after colon     :deli (left-square right-square))
  -  (object-block    :mult (key-value) :after colon     :deli (left-curly right-curly))
  -  
  -  (left-keyword    :read (string-literal) :bans (#\space #\newline #\,))
  -  (keyword-value   :read (left-keyword colon value))
  -  (string-literal  :read (quotes text quotes))
  -
  -  (text            :cond #'characterp)
  -  (numeric-value   :cond #'digit-char-p)
  -  
  -  (boolean-true    :word "true" )
  -  (boolean-false   :word "false")
  -  (null-value      :word "null" )
  -
  -  (whitespace      :char #\space)
  -  (newline         :char #\newline)
  -  (single-quotes   :char #\')
  -  (double-quotes   :char #\")
  -  (colon           :char #\:)
  -  (comma           :char #\,)
  -  (left-square     :char #\[)
  -  (right-square    :char #\])
  -  (left-curly      :char #\{)
  -  (right-curly     :char #\}))
  -
   (defmacro deftoken (name token-list &optional directives)
     (labels ((has (directive) (assoc directive directives)))
       (let* ((token-function-body
  -          (cond ((stringp (car token-list))
  -                 (cond (#1=(has 'to-interal)
  -                        `(progn
  -                           (skip-string-literal stream ,(first token-list)) #1#))
  -                       ((has 'ignore)
  -                        `(progn
  -                           (skip-string-literal stream ,(first token-list))))
  -                       (t `(collect-string-literal stream ,(first token-list)))))
  -                ((listp token-list)
  -                 (cond ((has 'rep) `(repeat-resolve-tokens stream ,token-list))
  -                       ((has 'ignore) `(skip-character stream ,token-list))
  -                       ((has 'collect)
  -                        `(collect-character-while
  -                          stream
  -                          #'(lambda (character)
  -                              (not (member character (resolve-banlist ',(has 'ban)))))))
  -                       ((characterp (car token-list))
  -                        (cond ((assoc 'rep directives) `(collect-character* stream ,(first token-list)))
  -                              (t `(collect-character stream ,(first token-list)))))
  -                       (t `(sequentially-resolve-tokens stream ,token-list)))))))
  -         `(defun ,name (stream)
  -            ,token-function-body))))
  +            (cond ((stringp (car token-list))
  +                   (cond (#1=(has 'to-interal)
  +                             `(progn
  +                                (skip-string-literal stream ,(first token-list)) #1#))
  +                         ((has 'ignore)
  +                          `(progn
  +                             (skip-string-literal stream ,(first token-list))))
  +                         (t `(collect-string stream ,(first token-list)))))
  +                  ((has 'rep) `(repeat-resolve-tokens stream ,token-list))
  +                  ((has 'ignore) `(skip-character-while stream ,token-list))
  +                  ((has 'collect)
  +                   `(collect-character-while
  +                     stream
  +                     #'(lambda (character)
  +                         (not (member character (resolve-banlist ',(has 'ban)))))))
  +                  ((characterp (car token-list))
  +                   (cond ((has 'rep) `(collect-character* stream ,(first token-list)))
  +                         (t `(collect-character stream ,(first token-list)))))
  +                  (t `(sequentially-resolve-tokens stream ,token-list)))))
  +      `(defun ,name (stream)
  +         ,token-function-body))))
   
  -(defun collect-character* (stream character)
  -  (format t "Will collect all ~a characters from stream ~a~%" character stream))
  -
  -(defun sequentially-resolve-tokens (stream token-list)
  -  (format t "Collect ~a from ~a in sequential order." token-list stream))
  -
  -(defun resolve-banlist (directives)
  -  (format t "A list of characters is returned from ~a~%" directives))
  -
  -(deftoken text nil ((collect) (ban quotes)))
  -
  +;;; JSON GRAMMAR
   (defparser json
  -  (value           (array-block object-block numeric-value boolean-value null-value string-literal value))
  -  (boolean-value   (boolean-true boolean-false))
  -  (array-block     (left-square whitespace value whitespace right-square) ((rep)))
  -  (object-block    (left-curly whitespace keyword-value whitespace right-curly) ((rep)))
  -  (keyword-value   (left-keyword spaces colon spaces value))
  -  (keyword-value*  (keyword-value comma))
  -  (string-literal  (quotes lexeme quotes))
  -  (quotes          (single-quotes double-quotes))
  +  (value           '(array-block object-block numeric-value boolean-value null-value string-literal value))
  +  (boolean-value   '(boolean-true boolean-false))
  +  (array-block     '(left-square whitespace value whitespace right-square) ((rep)))
  +  (object-block    '(left-curly whitespace keyword-value whitespace right-curly) ((rep)))
  +  (keyword-value   '(left-keyword spaces colon spaces value))
  +  (keyword-value*  '(keyword-value comma))
  +  (string-literal  '(quotes lexeme quotes))
  +  (quotes          '(single-quotes double-quotes))
     (lexeme          nil ((collect) (ban whitespace)))
     (text            nil ((collect) (ban quotes)))
  -  (boolean-true    ("true" ) ((to-internal t))) 
  -  (boolean-false   ("false") ((to-internal nil)))
  -  (null-value      ("null" ) ((to-internal '())))
  -  (whitespace      (spaces newline) ((ignore)))
  -  (spaces          ( #\space ))
  -  (newline         ( #\newline ))
  -  (single-quotes   ( #\' ))
  -  (double-quotes   ( #\" ))
  -  (colon           ( #\: ))
  -  (comma           ( #\, ))
  -  (left-square     ( #\[ ))
  -  (right-square    ( #\] ))
  -  (left-curly      ( #\{ ))
  -  (right-curly     ( #\} )))
  +  (boolean-true    '("true" ) ((to-internal t)))
  +  (boolean-false   '("false") ((to-internal nil)))
  +  (null-value      '("null" ) ((to-internal '())))
  +  (whitespace      '(spaces newline) ((ignore)))
  +  (spaces          '( #\space ))
  +  (newline         '( #\newline ))
  +  (single-quotes   '( #\' ))
  +  (double-quotes   '( #\" ))
  +  (colon           '( #\: ))
  +  (comma           '( #\, ))
  +  (left-square     '( #\[ ))
  +  (right-square    '( #\] ))
  +  (left-curly      '( #\{ ))
  +  (right-curly     '( #\} )))
  
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: 
  (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)
  