Next: Searching Lists, Previous: Cutting and Pasting Lists, Up: Lists
(SRFI 1) Returns a newly allocated copy of list containing only the elements satisfying predicate. Predicate must be a procedure of one argument.
(filter odd? '(1 2 3 4 5)) => (1 3 5)The non-standard procedure
keep-matching-items
(and its aliaslist-transform-positive
) are the same except that its arguments are reversed.
(SRFI 1) Like
filter
, except that the returned list contains only those elements not satisfying predicate.(remove odd? '(1 2 3 4 5)) => (2 4)The non-standard procedure
delete-matching-items
(and its aliaslist-transform-negative
) are the same except that its arguments are reversed.
(SRFI 1) Partitions the elements of list with predicate, and returns two values: the list of in-elements and the list of out-elements. The list is not disordered—elements occur in the result lists in the same order as they occur in the argument list. The dynamic order in which the various applications of
predicate
are made is not specified. One of the returned lists may share a common tail with the argument list.(partition symbol? '(one 2 3 four five 6)) => (one four five) (2 3 6)
(SRFI 1) Linear-update variants of
filter
,remove
andpartition
. These procedures are allowed, but not required, to alter the cons cells in the argumentlist
to construct the result lists.The non-standard procedures
keep-matching-items!
anddelete-matching-items!
bear a similar relationship tokeep-matching-items
anddelete-matching-items
, respectively.
Returns a newly allocated copy of list with all entries equal to element removed.
delq
useseq?
to compare element with the entries in list,delv
useseqv?
, anddelete
usesequal?
.
Returns a list consisting of the top-level elements of list with all entries equal to element removed. These procedures are like
delq
,delv
, anddelete
except that they destructively modify list.delq!
useseq?
to compare element with the entries in list,delv!
useseqv?
, anddelete!
usesequal?
. Because the result may not beeq?
to list, it is desirable to do something like(set! x (delete! x))
.(define x '(a b c b)) (delete 'b x) => (a c) x => (a b c b) (define x '(a b c b)) (delete! 'b x) => (a c) x => (a c) ;; Returns correct result: (delete! 'a x) => (c) ;; Didn't modify what x points to: x => (a c)
Returns a deletion procedure similar to
delv
ordelete!
. Deletor should be one of the procedureslist-deletor
orlist-deletor!
. Predicate must be an equivalence predicate. The returned procedure accepts exactly two arguments: first, an object to be deleted, and second, a list of objects from which it is to be deleted. If deletor islist-deletor
, the procedure returns a newly allocated copy of the given list in which all entries equal to the given object have been removed. If deletor islist-deletor!
, the procedure returns a list consisting of the top-level elements of the given list with all entries equal to the given object removed; the given list is destructively modified to produce the result. In either case predicate is used to compare the given object to the elements of the given list.Here are some examples that demonstrate how
delete-member-procedure
could have been used to implementdelv
anddelete!
:(define delv (delete-member-procedure list-deletor eqv?)) (define delete! (delete-member-procedure list-deletor! equal?))
These procedures each return a procedure that deletes elements from lists. Predicate must be a procedure of one argument. The returned procedure accepts exactly one argument, which must be a proper list, and applies predicate to each of the elements of the argument, deleting those for which it is true.
The procedure returned by
list-deletor
deletes elements non-destructively, by returning a newly allocated copy of the argument with the appropriate elements removed. The procedure returned bylist-deletor!
performs a destructive deletion.