anchor.diff:                                 :initial-contents ,initial-contents)))
        ,@body))
   
  -(defmethod to-string ((iter iterator))
  -  (with-slots (start end increment id quiet contents cyclic) iter
  -    (format nil "start: ~A, end: ~A, quiet: ~A, inc: ~A, cyclic: ~A, initial-contents: ~A ~%"
  -            start end quiet increment cyclic contents)))
  -
   (defun get-sequence-iter-varlist (all-clauses)
     (list
      (loop for clause in all-clauses
  
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:                    (end end)) iter
      (or (eq end *limit*) (funcall check index end))))
  
  (defmethod to-string ((iter iterator))
    (with-slots (start end increment id quiet contents cyclic) iter
      (format nil "start: ~A, end: ~A, quiet: ~A, inc: ~A, cyclic: ~A, initial-contents: ~A ~%"
              start end quiet increment cyclic contents)))
  
  (defmethod next ((iter iterator))
    (with-accessors ((index index)
                     (element initial-element)
  