Add TEST-NOT keyword argument to TREE-EQUAL
[jscl.git] / src / sequence.lisp
1 ;;; sequence.lisp
2
3 ;; JSCL is free software: you can redistribute it and/or
4 ;; modify it under the terms of the GNU General Public License as
5 ;; published by the Free Software Foundation, either version 3 of the
6 ;; License, or (at your option) any later version.
7 ;;
8 ;; JSCL is distributed in the hope that it will be useful, but
9 ;; WITHOUT ANY WARRANTY; without even the implied warranty of
10 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
11 ;; General Public License for more details.
12 ;;
13 ;; You should have received a copy of the GNU General Public License
14 ;; along with JSCL.  If not, see <http://www.gnu.org/licenses/>.
15
16 (defun not-seq-error (thing)
17   (error "`~S' is not of type SEQUENCE" thing))
18
19 (defmacro do-sequence ((elt seq &optional (index (gensym "i") index-p)) &body body)
20   (let ((nseq (gensym "seq")))
21     (unless (symbolp elt)
22       (error "`~S' must be a symbol." elt))
23     `(let ((,nseq ,seq))
24        (if (listp ,nseq)
25            ,(if index-p
26                 `(let ((,index -1))
27                    (dolist (,elt ,nseq)
28                      (incf ,index)
29                      ,@body))
30                 `(dolist (,elt ,nseq)
31                    ,@body))
32            (dotimes (,index (length ,nseq))
33              (let ((,elt (aref ,nseq ,index)))
34                ,@body))))))
35
36 (defun find (item seq &key key (test #'eql testp) (test-not #'eql test-not-p))
37   (do-sequence (x seq)
38     (when (satisfies-test-p item x :key key :test test :testp testp
39                             :test-not test-not :test-not-p test-not-p)
40       (return x))))
41
42 (defun find-if (predicate sequence &key key)
43   (if key
44       (do-sequence (x sequence)
45         (when (funcall predicate (funcall key x))
46           (return x)))
47       (do-sequence (x sequence)
48         (when (funcall predicate x)
49           (return x)))))
50
51 (defun position (elt sequence &key key (test #'eql testp)
52                      (test-not #'eql test-not-p))
53   (do-sequence (x sequence index)
54     (when (satisfies-test-p elt x :key key :test test :testp testp
55                            :test-not test-not :test-not-p test-not-p ) 
56       (return index))))
57
58 (defun remove (x seq &key key (test #'eql testp) (test-not #'eql test-not-p))
59   (cond
60     ((null seq)
61      nil)
62     ((listp seq)
63      (let* ((head (cons nil nil))
64             (tail head))
65        (do-sequence (elt seq)
66          (unless (satisfies-test-p x elt :key key :test test :testp testp 
67                                    :test-not test-not :test-not-p test-not-p)
68            (let ((new (list elt)))
69              (rplacd tail new)
70              (setq tail new))))
71        (cdr head)))
72     (t
73      (let (vector)
74        (do-sequence (elt seq index)
75          (if (satisfies-test-p x elt :key key :test test :testp testp 
76                                :test-not test-not :test-not-p test-not-p)
77              ;; Copy the beginning of the vector only when we find an element
78              ;; that does not match.
79              (unless vector
80                (setq vector (make-array 0))
81                (dotimes (i index)
82                  (vector-push-extend (aref seq i) vector)))
83              (when vector
84                (vector-push-extend elt vector))))
85        (or vector seq)))))
86
87
88 (defun some (function seq)
89   (do-sequence (elt seq)
90     (when (funcall function elt)
91       (return-from some t))))
92
93 (defun every (function seq)
94   (do-sequence (elt seq)
95     (unless (funcall function elt)
96       (return-from every nil)))
97   t)
98
99 (defun remove-if (func seq)
100   (cond
101     ((listp  seq) (list-remove-if   func seq nil))
102     ((arrayp seq) (vector-remove-if func seq nil))
103     (t (not-seq-error seq))))
104
105 (defun remove-if-not (func seq)
106   (cond
107     ((listp  seq) (list-remove-if   func seq t))
108     ((arrayp seq) (vector-remove-if func seq t))
109     (t (not-seq-error seq))))
110
111 (defun list-remove-if (func list negate)
112   (if (endp list)
113     ()
114     (let ((test (funcall func (car list))))
115       (if (if negate (not test) test)
116         (list-remove-if func (cdr list) negate)
117         (cons (car list) (list-remove-if func (cdr list) negate))))))
118
119 (defun vector-remove-if (func vector negate)
120   (let ((out-vector (make-array 0)))
121     (do-sequence (element vector i)
122       (let ((test (funcall func element)))
123         (when (if negate test (not test))
124           (vector-push-extend element out-vector))))
125     out-vector))
126
127 (defun subseq (seq a &optional b)
128   (cond
129     ((listp seq)
130      (if b
131        (let ((diff (- b a)))
132          (cond
133            ((zerop  diff) ()) 
134            ((minusp diff)
135             (error "Start index must be smaller than end index"))
136            (t
137             (let* ((drop-a (copy-list (nthcdr a seq)))
138                    (pointer drop-a))
139               (dotimes (_ (1- diff))
140                 (setq pointer (cdr pointer))
141                 (when (null pointer)
142                   (error "Ending index larger than length of list")))
143               (rplacd pointer ()) 
144               drop-a))))
145        (copy-list (nthcdr a seq))))
146     ((arrayp seq) 
147      (if b
148        (slice seq a b)
149        (slice seq a)))
150     (t (not-seq-error seq))))