anchor.diff:           (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.
   
  
positive.code:                       collect `(,(first sym) (symbolicate ',(second sym))))
       ,@body))
  
  (defmacro collect1 (collector &body body)
    "Bind COLLECTOR (with MACROLET) as a collector."
    (with-gensyms (head tail)
      `(let* ((,head (list nil))
              (,tail ,head))
         (macrolet ((,collector (&optional (x nil x-p))
                      (if x-p
                          `(setf (cdr ,',tail)
                                 (setf ,',tail (list ,x)))
                          `(cdr ,',head))))
           ,@body)
         (the list (cdr ,head)))))
  
  (defmacro collecting* (&body body)
    "Intern COLLECT in the current package and bind it as a collector
  with MACROLET."
    (with-syms (collect)
      `(collect1 ,collect
         ,@body)))
  
  (assert (equal '(0 1 2 3 4)
                 (collecting*
  
negative.code: (in-package #:serapeum)
  
  (export '(nlet collecting summing))
  
  ;;;# nlet
  
  