anchor.diff:        for iter-tmp = (if (listp tmp) (eval tmp) tmp)
         for result-tmp = (nth 2 clause)
         collect `(,var-name (next ,iter-tmp) (or (next ,iter-tmp) ,result-tmp)))
  -   `((some #'null (list ,@(loop for clause in all-clauses collect (car clause)))))))
  +   `((some #'null (list ,@(mapcar #'first all-clauses))))))
   
   (defun list-to-alist (lst)
     (labels ((rec (lst alst)
  
positive.code:               :text (to-string iter))))))
  
  (defmethod take (n (iter iterator))
    (let ((has-ended nil))
      (loop for i from 1 to n
         for value = (handler-case
                         (next iter)
                       (stop-iteration-exception ()
                         (setf has-ended T)))
         while (not has-ended)
         collect value)))
  
  (defmethod take-while (pred (iter iterator))
    (let ((has-ended nil))
      (loop for value = (handler-case
                            (next iter)
                          (stop-iteration-exception ()
                            (setf has-ended T)))
         while (and (not has-ended)
                    (funcall pred value))
         collect value)))
  
  (defmethod zip ((a iterator) (b iterator))
    (let ((has-ended nil))
      (loop
         for value-a = (handler-case
                           (next a)
                         (stop-iteration-exception ()
                           (setf has-ended T)))
         for value-b = (handler-case
                           (next b)
                         (stop-iteration-exception ()
                           (setf has-ended T)))
         while (not has-ended)
         collect (cons value-a value-b))))
  
  (defmacro make-iterator (&key (start 0) (end *limit*) (inc 1)
                             (id #'identity) (cyclic nil) (from-end nil)
  
negative.code:   (let ((iter (gensym "iterator")))
      `(let ((,iter
              (make-instance 'iterator :start (or ,start 0)
                             :end (or (when ,initial-contents
                                        (let ((len (1- (length ,initial-contents))))
                                          (cond
                                            ((= ,end *limit*) len)
                                            ((> ,end len) (error "length out of bounds")))))
                                      ,end *limit*)
                             :inc ,inc :id ,id :cyclic ,cyclic
                             :initial-contents ,initial-contents
                             :initial-element ,initial-element)))
  