((fn (dox examples chapters dox-new dox-build)
     (def dox-build (hsh name what texts args src chapters)
       (hash-set hsh 'name     name     )
       (hash-set hsh 'what     what     )
       (hash-set hsh 'texts    texts    )
       (hash-set hsh 'args     args     )
       (hash-set hsh 'src      src      )
       (hash-set hsh 'chapters chapters )
       hsh)

     (def dox-new (item)
       (hash-cons dox (hash-get item 'name) item)
       (dox-add-to-chapters (hash-get item 'chapters) item))

     (def dox-add-doc (name what texts args src chapters)
       (dox-new (dox-build (hash) name what texts args src chapters)))

     (def dox-add-to-chapter (chapter item)
       (hash-cons chapters chapter item))

     (def dox-add-to-chapters (chapters item)
       (cond chapters
             (do (dox-add-to-chapter  (car chapters) item)
                 (dox-add-to-chapters (cdr chapters) item))
             item))

     (def dox-add-examples (name example-exprs)
       (hash-cons examples name example-exprs))

     (def dox-lookup (sym) (hash-get dox sym))

     (def dox? (sym) (hash-key? dox sym))

     (def dox-names () (hash-keys dox))

     (def dox-get-attr (name attr)
       (cond (dox? name)
             (hash-get (car (dox-lookup name)) attr)))

     (def dox-chapter-names () (hash-keys chapters      ))
     (def dox-chapter   (name) (hash-get chapters name  ))
     (def dox-what-is?  (name) (dox-get-attr name 'what ))
     (def dox-src       (name) (dox-get-attr name 'src  ))
     (def dox-examples  (name) (hash-get examples name  ))
     (def dox-args      (name) (dox-get-attr name 'args ))
     (def dox-example-names () (hash-keys examples      )))
 (hash) (hash) (hash) nil)

(def filter-form (hsh form)
  ; if the car of 'form is a key of 'hsh, add the cdr of 'form to the value of the key in 'hsh
  ; otherwise add the form to the list whose key is nil
  (cond (cond (pair? form)
              (hash-key? hsh (car form)))
      (hash-cons hsh (car form) (cdr form))
      (hash-cons hsh        nil form))
  hsh)

(def rev-value-key (key keys old new)
  (hash-set new key (rev (hash-get old key)))
  (rev-value-keys keys old new))

(def rev-value-keys (keys old new)
  (cond keys
        (rev-value-key (car keys) (cdr keys) old new)
        new))

(def rev-values (hsh)
  (rev-value-keys (hash-keys hsh) hsh (hash)))

(def filter-forms (hsh forms)
  ; group forms by their first element, if the first element
  ; is already a key in hsh, collect all other elements under key nil
  (cond forms
        (filter-forms (filter-form hsh (car forms)) (cdr forms))
        (rev-values hsh)))

(def build-def-hash (hsh)
  (hash-set hsh 'comment nil)
  (hash-set hsh 'chapter nil)
  hsh)

(def define-mac-expr (name args body-forms)
  ; used internally by 'mac
  `(do (hash-set macs ',name (fn ,args ,@(hash-get body-forms nil)))
       (dox-add-doc ',name
                    'mac
                    ',(map car (hash-get body-forms 'comment))
                    ',args
                    '(mac ,name ,args ,@(hash-get body-forms nil))
                    ',(map car (hash-get body-forms 'chapter)))))

(hash-set macs 'mac
          (fn (name args . body)
              (define-mac-expr name args (filter-forms (build-def-hash (hash)) body))))

(dox-add-doc 'mac
             'mac
             '("define a new global macro")
             '(name args . body)
             '`(hash-set macs ',name (fn ,ooargs ,@body))
             '(nydp-core))

(dox-add-doc 'do
             'mac
             '("perform a series of operations")
             'args
             '`((fn nil ,@args))
             '(nydp-core))

(mac def-assign args `(assign ,@args))

(def define-def-expr (name args body-forms)
  ; used internally by 'def
  `(do (def-assign ,name (fn ,args ,@(hash-get body-forms nil)))
       (dox-add-doc ',name
                    'def
                    ',(map car (hash-get body-forms 'comment))
                    ',args
                    '(def ,name ,args ,@(hash-get body-forms nil))
                    ',(map car (hash-get body-forms 'chapter)))))

(mac def (name args . body)
  ; define a new function in the global namespace
  (chapter nydp-core)
  (define-def-expr name args (filter-forms (build-def-hash (hash)) body)))