anchor.diff:    (let ((*read-base* (base syntax)))
       (read-from-string (token-string syntax token))))
   
  -(defmethod token-to-object (syntax (token list-form) &rest args)
  -  (loop for child in (children token)
  -     if (typep child 'comma-at-form)
  -       nconc (listed (apply #'token-to-object syntax child args))
  -     else if (formp child)
  -       collect (apply #'token-to-object syntax child args)))
  -
   (defmethod token-to-object (syntax (token simple-vector-form) &key &allow-other-keys)
     (apply #'vector (call-next-method)))
   
  
positive.code: ;;;;;;;;;;;;;;;; Comma
  
  ;;; parse trees
  (defclass comma-form (form) ())
  (defclass comma-at-form (form) ())
  (defclass comma-dot-form (form) ())
  
  (define-parser-state |, | (form-may-follow) ())
  (define-parser-state |, form | (lexer-toplevel-state parser-state) ())
  
negative.code:                    :case case
                     :no-error t))
  
  (defgeneric token-to-object (syntax token &key no-error package read backquoted &allow-other-keys)
    (:documentation "Return the Lisp object `token' would evaluate
  to if read. An attempt will be made to construct objects from
  incomplete tokens. This function may signal an error if
  `no-error' is nil and `token' cannot be converted to a Lisp
  object. Otherwise, nil will be returned.")
    (:method :around (syntax (token t) &key package no-error &allow-other-keys)
             ;; Ensure that every symbol that is READ will be looked up
             ;; in the correct package. Also handle quoting.
             (flet ((act ()
                      (let ((*package* (or package
                                           (package-at-mark
                                            syntax (start-offset token)))))
  
                        (call-next-method))))
               (if no-error 
                   (ignore-errors (act))
                   (act))))
  