anchor.diff:                             (list (symbol->string name) `(or ,name nil))]
                             [(?name) (list (symbol->string name) `(or ,name nil))])
                           fields))
  -         (name (case symbol
  -                 [(hide ?x) x]
  -                 [?x x]))
  +         (name (symb-name symbol))
            (hide (and (list? symbol) (eq? (car symbol) 'hide)))]
       `(define ,name ,@(if hide '(:hidden) '())
          ,@(if (nil? docs) '() (list docs))
  
positive.code:     [(_ . ?x) (assoc-cdr x k or-val)]))
  
  (defun make-meta-decl (type-name constructor-name predicate-name clauses meta-clause fields-clause) :hidden
    (let* [(name-sym (case (car meta-clause)
                       [(hide ?x) x]
                       [?x x]))
           (hide (if (list? (car meta-clause)) (eql? (caar meta-clause) 'hide) false))
           (docs (or (cadr meta-clause) nil))
           (fields-clause-sym (gensym))
  
negative.code:                   `((.<! ,self ,(symbol->string name) ,val))
                    (or docs `nil)))])))
  
  (defun field-name (x) :hidden
    (case x
      [(immutable ?name . _) name]
      [(mutable ?name . _) name]
      [?name name]))
  
  (defun symb-name (x) :hidden
    (case x
      [(hide ?x) x]
      [?x x]))
  
  (defun make-constructor (docs type-name fields symbol spec) :hidden
    (let* [(lambda-list (map field-name fields))
  