Next: Searching Lists, Previous: Cutting and Pasting Lists, Up: Lists [Contents][Index]
(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 alias
list-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 alias
list-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 and partition. These procedures are allowed, but
not required, to alter the cons cells in the argument list to
construct the result lists.
The non-standard procedures keep-matching-items! and
delete-matching-items! bear a similar relationship to
keep-matching-items and delete-matching-items,
respectively.
Returns a newly allocated copy of list with all entries equal to
element removed. delq uses eq? to compare
element with the entries in list, delv uses
eqv?, and delete uses equal?.
Returns a list consisting of the top-level elements of list with
all entries equal to element removed. These procedures are like
delq, delv, and delete except that they
destructively modify list. delq! uses eq? to
compare element with the entries in list, delv! uses
eqv?, and delete! uses equal?. Because the result
may not be eq? 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 or delete!.
Deletor should be one of the procedures list-deletor or
list-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 is list-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 is
list-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 implement
delv and delete!:
(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 by
list-deletor! performs a destructive deletion.
Next: Searching Lists, Previous: Cutting and Pasting Lists, Up: Lists [Contents][Index]