anchor.diff:                when (funcall pred (funcall key x))
                   return i)))
     (:method (pred (sequence abstract-list) &rest args &key from-end (start 0) end (key #'identity))
  -    (if (or end from-end)
  +    (if from-end
           (apply #'cl:position-if pred (coerce sequence 'list) args)
           (loop with seq = (drop start sequence)
                 with i = 0
                 for x = (pop seq)
  -              until (emptyp seq)
  +              until (or (and end
  +                             (<= end i))
  +                        (emptyp seq))
                 when (funcall pred (funcall key x))
                   return (+ i start)
                 do (incf i)))))
  
positive.code:                            (values
                              (cl:append (take start sequence)
                                         (nreverse subseqs))
                              i))))
          (apply #'split-sequence:split-sequence-if pred (coerce sequence 'list) args))))
  
  
  
negative.code:   (:method (sequence1 (sequence2 abstract-list) &rest args &key from-end (test #'eql) (start1 0) end1 (start2 0) end2 (key #'identity))
      (when (typep sequence1 'abstract-sequence)
        (setq sequence1 (coerce sequence1 'list)))
      (if from-end
          (apply #'cl:mismatch sequence1 (coerce sequence2 'list) args)
          (if (funcall test
                       (funcall key (elt sequence2 start2))
                       (funcall key (elt sequence1 start1)))
              (progn
                (setq sequence1 (subseq sequence1 start1 end1))
                (loop with first-el = (funcall key (car sequence1))
                      with len = (cl:length sequence1)
                      with seq = (drop start2 sequence2)
                      with i = 0
                      until (or (and end2
                                     (< end2 (+ i len)))
                                (emptyp seq))
                      for x = (pop seq)
                      when (funcall test (funcall key x) first-el)
                        return (let ((res (mismatch (drop 1 sequence1) (take (1- len) seq)
                                                    :test test :key key)))
                                 (if res
                                     (+ start2 res)
                                     nil))
                      do (incf i)))
              0))))
  
  
  