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: 
  (defun gen-def (name ll body &extra) :hidden
    (case name
      [(hide ?x) `(defun ,x ,ll :hidden ,@body ,@extra)]
      [?x `(defun ,x ,ll ,body ,@extra)]))
  
  (defun map-name (f field) :hidden
    (case field
  
negative.code:           (case name
              [(?n ?c ?p) (values-list n c p)]
              [?n (values-list n (sym.. 'make- n) (sym.. n '?))]))
           ((docs clauses)
            (if (string? (car clauses))
              (values-list (car clauses) (cdr clauses))
              (values-list nil clauses)))
           (fields (assoc-cdr clauses 'fields '()))
           (constructor (assoc-cdr clauses 'constructor '(new new)))]
      (let* [(work '())]
        (push-cdr! work (make-constructor docs 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)))
  