anchor.diff:                         if (symbolp binding)
                            collect `(,binding ,binding)
                          else collect binding))
  -  `(nlet-2 ,name ,bindings ,@body))
  -
  -(defmacro nlet-1 (name (&rest bindings) &body body)
  -  `(funcall
  -    (named-lambda ,name (mapcar #'first bindings)
  -      ,@body)
  -    ,@(mapcar #'second bindings)))
  -
  -(defmacro nlet-2 (name (&rest bindings) &body body)
     (multiple-value-bind (body decls)
         (parse-body body)
       (let* ((bindings (mapcar #'ensure-list bindings))
  
positive.code:          (declare (inline ,collect))
           ,@body))))
  
  (defmacro with-collectors* (collectors &body body)
    (if (null collectors)
        `(progn ,@body)
        `(collect1 ,(first collectors)
           (with-collectors* ,(rest collectors)
             ,@body))))
  
  (defmacro with-collectors (collectors &body body)
    (if (endp collectors)
        `(progn ,@body)
        (let ((collector (first collectors)))
          `(collect1 ,collector
             (flet ((,collector (&optional (x nil x?))
                      (if x?
                          (,collector x)
                          (,collector))))
               (declare (inline ,collector))
               (with-collectors ,(rest collectors)
                 ,@body))))))
  
  (defmacro hashing ((&rest hash-table-args)
                     &body body)
    "Within BODY, bind HASH to a function that adds its two args to a
  hash table; return the hash table at the end."
    (with-syms (hash)
      (with-gensyms (table)
        `(let ((,table (make-hash-table ,@hash-table-args)))
           (flet ((,hash (k v)
                    (setf (gethash k ,table) v)))
             ,@body
             ,table)))))
  
  (defmacro reducing (name fun &body body)
    (with-gensyms (first-run so-far new newp)
      `(block ,name
         (let ((,so-far nil)
               (,first-run t))
           (flet ((,name (&optional (,new nil ,newp))
                    (if ,newp
                        (if ,first-run
                            (setf ,first-run nil
                                  ,so-far ,new)
                            (callf ,fun ,so-far ,new))
                        ,so-far)))
             ,@body
             ,so-far)))))
  
  (defmacro folding (name initial fun &body body)
    (with-gensyms (value new newp)
      `(block ,name
         (let ((,value ,initial))
           (flet ((,name (&optional (,new nil ,newp))
                    (if ,newp
                        (callf ,fun ,value ,new)
                        ,value)))
             ,@body
             ,value)))))
  
  (defmacro summing (&body body)
    "Within BODY, bind `sum' to a function that gathers numbers to sum.
  
  
negative.code: (in-package #:serapeum)
  
  (export '(nlet collecting summing))
  
  ;;;# nlet
  
  