anchor.diff:        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)
  +             (cond 
  +               ((null lst) alst)
  +               ((null (cdr lst)) (error "odd number of args"))
  +               (T (rec (cddr lst) (cons (cons (first lst) (second lst)) alst))))))
  +    (nreverse (rec lst '()))))
  +
  +(defun resolve-key-args(clause key-args &optional (key-name-p T))
  +  (let* ((pairs (list-to-alist clause))
  +         (args (car pairs))
  +         (others (cdr pairs))
  +         (get #'(lambda(key) (cdr (assoc key others)))))
  +    (append (list (car args) (cdr args)) 
  +            (loop for key in key-args
  +               for value = (funcall get key) 
  +               appending (if key-name-p (list key value) (list value))))))
  +
   (defmacro do-sequence-iterators (((var iter &optional result) &rest more-clauses) &body body)
     (let ((all-clauses (cons (list var iter result) more-clauses)))
       `(do ,@(get-sequence-iter-varlist all-clauses)
  
positive.code:    (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
  
negative.code:        (when (not (listp initial-contents))
           (setf comparer #'(lambda(n seq) (elt seq n))))
         (if ,from-end
             (progn
               (rotatef start length)
               (setf index start
                     bound-check #'>=
                     increment (* -1 ,inc)))
             (setf index start)))
       tmp))
  
  (defmacro with-iterator ((name &key (start 0) (length -1) (increment 1)
                                 (initial-contents nil) (id #'identity)) &body body)
    `(let ((,name (make-iterator :start ,start :length ,length
                                 :inc ,increment :id ,id
                                 :initial-contents ,initial-contents)))
       ,@body))
  
  (defmethod to-string ((iter iterator))
  