anchor.diff:      (iter (initially (setf i (lower-bound interval)))
             (repeat (1- n))
             (for i = (next-element-in-set interval i))
  -          (finally (return (if (funcall (element-member-fn interval) interval i)
  -                               i nil)))))
  +          (finally 
  +           (return (if (funcall (element-member-fn interval) interval i)
  +                       i
  +                       nil)))))
   
     (:method ((mi multi-interval) (n integer))
       (iter (for interval in (intervals mi))
  
positive.code: ;; isn't standard use of an interval and could be an error. On the
  ;; other hand, I do rely on this behavior to easily do interval
  ;; operations. But it will break code if we try to define intervals on
  ;; circular sets.
  (defmethod make-interval :around (interval lower upper &rest args)
    (declare (ignore args interval))
    (if (< upper lower)
  
negative.code:   (lower-bound (car (intervals mi))))
  (defmethod upper-bound ((mi multi-interval))
    (upper-bound (car (last (intervals mi)))))
  
  (defmethod element-member-p ((mi multi-interval) element)
    (some (rcurry #'element-member-p element) (intervals mi)))
  
  (defmethod next-element-in-set ((mi multi-interval) element)
    (iter (generate interval in (intervals mi))
          (when (<= element (upper-bound (next interval)))
              (if (< element (upper-bound interval))
                  (return (next-element-in-set interval element))
                  (return (lower-bound (next interval)))))))
  
  (defmethod previous-element-in-set ((mi multi-interval) element)
    (iter (generate interval in (reverse (intervals mi)))
          (when (<= (lower-bound (next interval)) element)
            (if (= element (lower-bound interval))
                (return (upper-bound (next interval)))
                (return (previous-element-in-set interval element))))))
  
  
  ;;; ------------------------------------
  