anchor.diff:     (quiet :initform T :initarg :quiet
             :documentation "Whether to raise an error when iterations are exhausted")
      (cyclic :initform nil :initarg :cyclic
  -           :documentation "Whether the iteration is cyclic, in case where values are supplied the sequence re-iterated otherwise the iteration resets the index to start")
  -   (values :initform nil :initarg :values
  -           :documentation "A list/sequence of values to be iterated")
  -   (bound-check :initform #'<= :initarg :reverse
  -                :documentation "When T, direction of iteration is reversed")
  -   (comparer :initform #'(lambda(n values) (nth n values))
  -             :documentation "Function to access to individual members of a values, #'nth for lists, #'elt for others")))
  +           :documentation "Whether the iteration is cyclic, in case where initial-contents are supplied the sequence re-iterated otherwise the iteration resets the index to start")
  +   (initial-contents :initform nil :initarg :initial-contents
  +                     :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-endd")
  +   (comparer :initform #'nth
  +             :documentation "Function to access to individual members of a initial-contents, #'nth for lists, #'elt for others")))
   
  -(defmethod reset((iter iterator))
  +(defmethod reset ((iter iterator))
     (with-slots (start index) iter
       (setf index start)))
   
  -(defmethod next((iter iterator))
  -  (with-slots (index end increment id quiet cyclic
  -                     comparer bound-check values) iter
  -    (if (or (funcall bound-check index end) (eq end -1))
  +(defmethod next ((iter iterator))
  +  (with-slots (index length increment id quiet cyclic initial-element
  +                     comparer bound-check initial-contents) iter
  +    (if (or (funcall bound-check index length) (eq length -1))
           (let ((current
  -               (funcall id (if values
  -                               (funcall comparer index values)
  -                               index))))
  +               (funcall id (cond
  +                             ((not (null initial-contents)) (funcall comparer index initial-contents))
  +                             ((not (null initial-element)) initial-element)
  +                             (T index)))))
             (incf index increment)
             current)
           (if cyclic
  
positive.code:      while (and i j)
       collect (cons i j)))
  
  (defmacro make-iterator(&key (start 0) (end -1) (inc 1)
                            (id #'identity) (values ()) (cyclic nil) (reverse nil))
    `(let ((tmp (make-instance 'iterator :start ,start
                               :end (if (null ,values)
                                        ,end
                                        (1- (length ,values)))
                               :inc ,inc :id ,id :values ,values :cyclic ,cyclic)))
       (with-slots (start end index values increment comparer bound-check) tmp
         (when (not (listp values))
           (setf comparer #'(lambda(n seq) (elt seq n))))
         (if ,reverse
           (setf start end
                 index end
                 end ,start
                 bound-check #'>=
                 increment (* -1 ,inc))
           (setf index start)))
       tmp))
           
  (defmacro with-iterator((name &key (start 0) (end -1) (increment 1)
                                (values nil) (id #'identity)) &body body)
    `(let ((,name (make-iterator :start ,start
                                 :end ,end :inc ,increment
                                 :values ,values :id ,id)))
       ,@body))
  
  (defmethod to-string((iter iterator))
    (with-slots (start end increment id quiet values cyclic) iter
      (format T "start: ~A, end: ~A, quiet: ~A, inc: ~A, cyclic: ~A, values: ~A ~%"
              start end quiet increment cyclic values)))
  
negative.code:           :documentation "The start of the iteration, either an index value or integer value to mark the start of iteration")
     (index :initform 0
            :documentation "the current index of the iteration") 
     (length :initform -1 :initarg :length
          :documentation "The length of the iteration, -1 denotes an infinite iteration, for lists/sequences, the sequence length limits the iteration")
     (increment :initform 1 :initarg :inc
                :documentation "the increment of the iteration")
     (id :initform #'identity :initarg :id
  