anchor.diff:      [(hide ?x) (list 'hide (f x))]
       [?x (f x)]))
   
  -(defun field->def (nm field) :hidden
  -  (let* [(self (gensym))
  -         (val (gensym))]
  -    (case field
  -      [(immutable ?name (optional (string? @ ?docs)))
  -       (list
  -         (gen-def (map-name (cut sym.. nm '- <>) name)
  -                `(,self)
  -                `((.> ,self ,(symbol->string name)))
  -                (or docs `nil)))]
  -      [(immutable ?name ?accessor (optional (string? @ ?docs)))
  -       (list
  -         (gen-def accessor
  -                `(,self)
  -                `((.> ,self ,(symbol->string name)))
  -                (or docs `nil)))]
  -      [(symbol? @ ?name)
  -       (field->def nm (list 'immutable name))]
  -      [(mutable ?name (optional (string? @ ?docs)))
  -       (snoc
  -         (field->def nm (list 'immutable name))
  -         (gen-def (map-name (cut sym.. 'set- nm '- <> '!) name)
  -                  (list self val)
  -                  `((.<! ,self ,(symbol->string name) ,val))
  -                  (or docs `nil)))]
  -      [(mutable ?name ?getter ?setter (optional (string? @ ?docs)))
  -       (snoc
  -         (field->def nm (list 'immutable name getter))
  -         (gen-def setter
  -                  (list self val)
  -                  `((.<! ,self ,(symbol->string name) ,val))
  -                  (or docs `nil)))])))
  -
   (defun field-name (x) :hidden
     (case x
       [(immutable ?name . _) name]
  
positive.code:                         `(lambda (,'_ ,self)
                             (list ,@(map (lambda (x)
                                            `(.> ,self
                                                 ,(symbol->string (if (list? x)
                                                                    (cadr x)
                                                                    x))))
                                          fields-clause)))))]
      `(define ,name-sym ,@(if hide '(:hidden) '()) ,@(if docs (list docs) '())
         (let* [(,fields-clause-sym ',fields-clause)]
  
negative.code:                                `((and (table? ,self)
                                        (= (.> ,self :tag) ,(symbol->string name))
                                        ,@(map (lambda (x)
                                                 (let* [(x (symb-name (field-name x)))]
                                                   `(/= (.> ,self ,(symbol->string x)) nil)))
                                               fields))))))
        (map (lambda (x)
  