anchor.diff:    ((context :initarg :context :reader context))
     (:report (lambda (condition stream)
                (format stream
  -                     "EOF encountered while reading ~a"
  +                     "EOF encountered while reading '~a'"
                        (context condition))))
     (:documentation "Error raised when EOF is encountered while reading."))
   
  
positive.code:     ("@" (expand-quote reader))
      (t (read-atom reader))))
  
  (defun read-str (string)
    (read-form (make-token-reader :tokens (tokenize string))))
  
negative.code:                                       ("@" "deref")))))
      (make-mal-list (list quote-sym (read-form reader)))))
  
  (defun read-mal-sequence (reader &optional (type 'list) &aux forms)
    (let ((context (string-downcase (symbol-name type)))
          (delimiter (if (equal type 'list) ")" "]")))
  
      ;; Consume the opening brace
      (consume reader)
  
      (setf forms (loop
                     until (string= (peek reader) delimiter)
                     collect (read-form-or-eof reader context)))
  
      ;; Consume the closing brace
      (consume reader)
  
      (apply type forms)))
  
  (defun read-hash-map (reader)
    (let ((map (make-mal-value-hash-table))
          (context "hash-map"))
  
      ;; Consume the open brace
      (consume reader)
  
      (loop
         until (string= (peek reader) "}")
         do (setf (hashref (read-form-or-eof reader context) map)
                  (read-form-or-eof reader context)))
  
      ;; Consume the closing brace
      (consume reader)
  
      map))
  
  (defun read-atom (reader)
    (let ((token (next reader)))
      (cond ((string= token "false") mal-false)
            ((string= token "true") mal-true)
            ((string= token "nil") mal-nil)
            ((char= (char token 0) #\") (make-mal-string (parse-string token)))
            ((char= (char token 0) #\:) (make-mal-keyword token))
            ((scan *number-re* token) (make-mal-number (read-from-string token)))
            (t (make-mal-symbol token)))))
  
  (defun read-form-with-meta (reader)
    (consume reader)
  
    (let ((meta (read-form-or-eof reader "object meta"))
          (value (read-form-or-eof reader "object meta")))
      (make-mal-list (list (make-mal-symbol "with-meta") value meta))))
  
  (defun read-form (reader)
    (switch ((peek reader) :test #'equal)
      (nil nil)
      ("(" (make-mal-list (read-mal-sequence reader 'list)))
      ("[" (make-mal-vector (read-mal-sequence reader 'vector)))
      ("{" (make-mal-hash-map (read-hash-map reader)))
      ("^" (read-form-with-meta reader))
      ("'" (expand-quote reader))
  