anchor.diff:                   [?x x]))
            (hide (and (list? type-name) (eq? (car type-name) 'hide)))]
       `(define ,name ,@(if hide '(:hidden) '())
  +       ,@(if (nil? docs) '() (list docs))
          (let* [(,(car spec)
                   (lambda ,lambda-list
                     { :tag ,(symbol->string type-name)
  
positive.code:           (case name
              [(?n ?c ?p) (values-list n c p)]
              [?n (values-list n (sym.. 'make- n) (sym.. n '?))]))
           (fields (assoc-cdr clauses 'fields '()))
           (constructor (assoc-cdr clauses 'constructor '(new new)))]
      (let* [(work '())]
        (push-cdr! work (make-constructor name fields constr constructor))
        (push-cdr! work (gen-def pred '(self) `(= (.> ,'self :tag) ,(symbol->string name))))
        (map (lambda (x)
               (map (cut push-cdr! work <>) (field->def name x)))
  
negative.code: 
  (defun field->def (nm field) :hidden
    (case field
      [(immutable ?name (optional (string? @ ?docs)))
       (list
         (gen-def (map-name (cut sym.. nm '- <>) name)
                '(self)
                `((.> ,'self ,(symbol->string name)))
                docs))]
      [(immutable ?name ?accessor (optional (string? @ ?docs)))
       (list
         (gen-def accessor
                '(self)
                `((.> ,'self ,(symbol->string name)))
                docs))]
      [(symbol? @ ?name)
       (field->def name (list 'immutable name))]
      [(mutable ?name (optional (string? @ ?docs)))
       (snoc
         (field->def nm (list 'immutable name))
         (gen-def (map-name (cut sym.. 'set- nm '- <> '!) name)
                  '(self val)
                  `((.<! ,'self ,(symbol->string name) ,'val))
                  docs))]
      [(mutable ?name ?getter ?setter (optional (string? @ ?docs)))
       (snoc
         (field->def nm (list 'immutable name getter))
         (gen-def setter
                  '(self val)
                  `((.<! ,'self ,(symbol->string name) ,'val))
                  docs))]))
  
  (defun make-constructor (docs type-name fields symbol spec) :hidden
    (let* [(lambda-list (map (function
                               [((immutable ?name . _)) name]
                               [((mutable ?name . _)) name]
  