(let ((,elt (aref ,nseq ,index)))
,@body))))))
-(defun find (item seq &key key (test #'eql))
- (if key
- (do-sequence (x seq)
- (when (funcall test (funcall key x) item)
- (return x)))
- (do-sequence (x seq)
- (when (funcall test x item)
- (return x)))))
+(defun find (item seq &key key (test #'eql testp) (test-not #'eql test-not-p))
+ (do-sequence (x seq)
+ (when (satisfies-test-p item x :key key :test test :testp testp
+ :test-not test-not :test-not-p test-not-p)
+ (return x))))
(defun find-if (predicate sequence &key key)
(if key
(when (funcall predicate x)
(return x)))))
-(defun position (elt sequence &key (test #'eql))
- (do-sequence (x seq index)
- (when (funcall test elt x)
- (return index))))
+(defun position (elt sequence
+ &key key (test #'eql testp)
+ (test-not #'eql test-not-p)
+ (start 0) end)
+ ;; TODO: Implement START and END efficiently for all the sequence
+ ;; functions.
+ (let ((end (or end (length sequence))))
+ (do-sequence (x sequence index)
+ (when (and (<= start index)
+ (< index end)
+ (satisfies-test-p elt x
+ :key key :test test :testp testp
+ :test-not test-not :test-not-p test-not-p))
+ (return index)))))
+
+;; TODO: need to support &key from-end
+(defun position-if (predicate sequence
+ &key key (start 0) end)
+ ;; TODO: Implement START and END efficiently for all the sequence
+ ;; functions.
+ (let ((end (or end (length sequence))))
+ (do-sequence (x sequence index)
+ (when (and (<= start index)
+ (< index end)
+ (funcall predicate (if key (funcall key x) x)))
+ (return index)))))
-(defun remove (x seq)
+(defun position-if-not (predicate sequence
+ &key key (start 0) end)
+ (position-if (complement predicate) sequence :key key :start start :end end))
+
+(defun remove (x seq &key key (test #'eql testp) (test-not #'eql test-not-p))
(cond
((null seq)
nil)
(let* ((head (cons nil nil))
(tail head))
(do-sequence (elt seq)
- (unless (eql x elt)
+ (unless (satisfies-test-p x elt :key key :test test :testp testp
+ :test-not test-not :test-not-p test-not-p)
(let ((new (list elt)))
(rplacd tail new)
(setq tail new))))
(t
(let (vector)
(do-sequence (elt seq index)
- (if (eql x elt)
+ (if (satisfies-test-p x elt :key key :test test :testp testp
+ :test-not test-not :test-not-p test-not-p)
;; Copy the beginning of the vector only when we find an element
;; that does not match.
(unless vector
(if b
(let ((diff (- b a)))
(cond
- ((zerop diff) ())
+ ((zerop diff) ())
((minusp diff)
(error "Start index must be smaller than end index"))
(t
- (let* ((drop-a (nthcdr a seq))
+ (let* ((drop-a (copy-list (nthcdr a seq)))
(pointer drop-a))
- (dotimes (n (1- diff))
+ (dotimes (_ (1- diff))
(setq pointer (cdr pointer))
(when (null pointer)
(error "Ending index larger than length of list")))
- (setf (cdr pointer) nil)
+ (rplacd pointer ())
drop-a))))
- (nthcdr a seq)))
- ((arrayp seq)
- (if b
- (slice seq a b)
- (slice seq a)))
+ (copy-list (nthcdr a seq))))
+ ((vectorp seq)
+ (let* ((b (or b (length seq)))
+ (size (- b a))
+ (new (make-array size :element-type (array-element-type seq))))
+ (do ((i 0 (1+ i))
+ (j a (1+ j)))
+ ((= j b) new)
+ (aset new i (aref seq j)))))
(t (not-seq-error seq))))
+
+(defun copy-seq (sequence)
+ (subseq sequence 0))