anchor.diff:  (defclass string-expression ()
     ((string :initarg :string)))
   
  +(defclass namespace ()
  +  ((name :initarg :name)
  +   (declarations :initarg :declarations)))
  +
  +(defclass namespace-declaration ()
  +  ((var :initarg :var)
  +   (value :initarg :value)
  +   (type :initarg :type)
  +   (export-p :initarg :export-p)
  +   (comment :initarg :comment)))
  +
   (defvar *token-iterator*)
   
   (defun next-token ()
  
positive.code:   (when (match token-type string)
      (next-token)))
  
  (defun exact (token-type &optional string)
    (or (accept token-type string)
        (error "Token not expected: ~S" (ahead-token))))
  
  (defun parse-type-expression ()
    (labels ((type-name ()
  
negative.code:                    (make-instance 'type-or :types types)))))
      (type-or)))
  
  (defun parse-comments ()
    (flet ((comment-to-string (comment)
             (ppcre:regex-replace-all "\\n\\s*"
                                      (token-string comment)
                                      (string #\newline))))
      (string-trim '(#\newline #\space #\tab)
                   (with-output-to-string (out)
                     (loop :for comment := (accept 'comment)
                           :while comment
                           :do (write-line (comment-to-string comment) out))))))
  
  (defun parse-interface-expression ()
    (exact 'operator "{")
    (let ((elements '()))
      (loop
        (let ((comment (parse-comments)))
          (if-let ((element-name (accept 'word)))
            (let ((optional-p (not (null (accept 'operator "?")))))
              (exact 'operator ":")
  