anchor.diff:       while (and i j)
        collect (cons i j)))
   
  -(defmacro make-iterator (&key (start 0) (end -1) (inc 1) (id #'identity) (cyclic nil)
  +(defmacro make-iterator (&key (start 0) (end *limit*) (inc 1) (id #'identity) (cyclic nil)
                              (initial-contents ()) (from-end nil) (initial-element nil))
     (let ((iter (gensym "iterator")))
       `(let ((,iter (make-instance 'iterator :start (or ,start 0)
  -                                 :end (or (when (not (null ,initial-contents))
  -                                            (let ((len (length ,initial-contents)))
  -                                              (if (= ,end -1)
  +                                 :end (let ((len (1- (length ,initial-contents)))
  +                                            (end (or ,end *limit*)))
  +                                        (or (when (not (null ,initial-contents))
  +                                              (if (= end *limit*)
                                                     len
  -                                                  (when (>= ,end len)
  -                                                    (error "length out of bounds")))))
  -                                          ,end)
  +                                                  (when (> end len)
  +                                                    (error "length out of bounds"))))
  +                                            end))
                                    :inc ,inc :id ,id :cyclic ,cyclic
                                    :initial-contents ,initial-contents
                                    :initial-element ,initial-element)))
  
positive.code:                      :documentation "A list/sequence of initial-contents to be iterated")
     (initial-element :initform nil :initarg :initial-element
                      :documentation "When supplied and no initial-contents supplied, iteration returns the value instead of the index")
     (bound-check :initform #'< :initarg :from-end
                  :documentation "When T, direction of iteration is from-end")
     (accessor :initform #'nth
               :documentation "Function to access to individual members of a initial-contents, #'nth for lists, #'elt for others")))
  
negative.code:              (progn
                 (rotatef start end)
                 (setf index start
                       bound-check #'>=
                       increment (* -1 ,inc)))
               (setf index start)))
         (to-string ,iter)
         ,iter)))
  
  (defmacro with-iterator ((name &key (start 0) (end *limit*) (increment 1)
                                 (initial-contents nil) (id #'identity)) &body body)
    `(let ((,name (make-iterator :start ,start :end ,end
                                 :inc ,increment :id ,id
  