anchor.diff:  
   (defun gen-def (name ll body &extra) :hidden
     (case name
  -    [(hide ?x) `(defun ,x ,ll :hidden ,@body ,@extra)]
  -    [?x `(defun ,x ,ll ,body ,@extra)]))
  +    [(hide ?x) `(defun ,x ,ll :hidden ,@extra ,@body)]
  +    [?x `(defun ,x ,ll ,@extra ,@body)]))
   
   (defun map-name (f field) :hidden
     (case field
  
positive.code:                  [?x x]))
           (hide (and (list? type-name) (eq? (car type-name) 'hide)))]
      `(define ,name ,@(if hide '(:hidden) '())
         (let* [(,(car spec)
                  (lambda ,lambda-list
                    { :tag ,(symbol->string type-name)
  
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]
  