anchor.diff:                :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)))
  +  (let ((values ()))
  +    (handler-case
  +        (dotimes (i n)
  +          (push (next iter) values))
  +      (stop-iteration-exception ()))
  +    (nreverse values)))
   
   (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)))
  +  (let ((values ()))
  +    (handler-case
  +        (loop for value = (next iter)
  +           while (funcall pred value)
  +           do (push value values))
  +      (stop-iteration-exception ()))
  +    (nreverse values)))
   
   (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))))
  +  (let ((vals ()))
  +    (handler-case 
  +        (loop for value-a = (next a)
  +           for value-b = (next b)
  +           do (push (cons value-a value-b) vals))
  +      (stop-iteration-exception ()))
  +    (nreverse vals)))
   
   (defmacro make-iterator (&key (start 0) (end *limit*) (inc 1)
                              (id #'identity) (cyclic nil) (from-end nil)
  
positive.code:       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)))))))
  
  (defun list-to-alist (lst)
    (labels ((rec (lst alst)
  
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)))
  