anchor.diff:    (apply $list args))
   
   (defmethod iter ((list list))
  -  (<list-iter> list))
  +  (list-iter list))
   
   (defmethod len ((list list))
     (list-len list))
  
positive.code: (defmethod add ((list list) elt)
    (list-add list elt))
  
  (defclass <list-iter> () 
    (list
     i))
  
  (defun <list-iter> ((list list))
    (let ((iter (make <list-iter>)))
      (setf (.list iter) list)
      (setf (.i iter) 0)
      iter))
  
  (defmethod has-next ((iter <list-iter>))
    (< (.i iter) (len (.list iter))))
  
  (defmethod next ((iter <list-iter>))
    (inc (.i iter)))
  
  (defmethod now ((iter <list-iter>))
    (elt (.list iter) (.i iter)))
  
  (defmethod elt ((form compound-form) i)
  
negative.code:           (each $next iters))))
    into)
  
  (defclass number-iter ()
    (i
     max))
  
  (defun number-iter (max)
    (let ((iter (make number-iter)))
      (setf (.i iter) 0)
      (setf (.max iter) max)
      iter))
  
  (defmethod iter ((max number))
    (number-iter max))
  
  (defmethod has-next ((iter number-iter))
    (< (.i iter) (.max iter)))
  
  (defmethod now ((iter number-iter))
    (.i iter))
  
  (defmethod next ((iter number-iter))
    (inc (.i iter)))
  
  (defmacro dotimes (var-and-ct &rest body)
  