The procedures second, third, fourth,
fifth, sixth, seventh, and
eighth access the corresponding element from a list.
Applies f to the car of each element of l (from
left to right) until f returns a true value, in which case that
element is returned. If f does not return a true value for the
car of any element of l, #f is returned.
Returns #t if v is a value created with cons,
#f otherwise.
The empty list.
Returns #t if v is the empty list, #f otherwise.
Applies f to each element in l (from left to right) and
returns a new list that is the same as l, but omitting all the
elements for which f returned #f.
Returns the first element of the list l. (The first
procedure is a synonym for car.)
(foldl f init l ···1) PROCEDURE
Like map, foldl applies a procedure f to the
elements of one or more lists. While map combines the return
values into a list, foldl combines the return values in an
arbitrary way that is determined by f. Unlike foldr,
foldl processes l in constant space (plus the space
for each call to f).
If foldl is called with n lists, the f procedure
takes n+1 arguments. The extra value is the combined return
values so far. The f procedure is initially invoked with the
first item of each list; the final argument is init. In
subsequent invocations of f, the last argument is the return
value from the previous invocation of f. The input lists are
traversed from left to right, and the result of the whole
foldl application is the result of the last application of
f. (If the lists are empty, the result is init.)
For example, reverse can be defined in terms of foldl:
(definereverse(lambda (l) (foldlcons'() l)))
(foldr f init l ···1) PROCEDURE
Like foldl, but the lists are traversed from right to left.
Unlike foldr, foldl processes l in space
proportional to the length of l (plus the space for each call
to f).
For example, a restricted map (that works only on single-argument
procedures) can be defined in terms of foldr:
(define simple-map (lambda (flist) (foldr(lambda (v l) (cons(f v) l)) '()list)))
Returns the last pair in list, raising an error if
list is not a pair (but list does not have
to be a proper list).
Applies f to each element of l (from left to right) until
f returns a true value for some element, in which case the
tail of l starting with that element is returned. If
f does not return a true value for any element of
l, #f is returned.
(mergesort list less-than?) PROCEDURE
Sorts list using the comparison procedure less-than?.
This implementation is not stable (i.e., if two elements in the input
are ``equal,'' their relative positions in the output may be
reversed).
(quicksort list less-than?) PROCEDURE
Sorts list using the comparison procedure less-than?.
This implementation is not stable (i.e., if two elements in the input
are ``equal,'' their relative positions in the output may be
reversed).
(remove item list [equal?]) PROCEDURE
Returns list without the first instance of item, where an
instance is found by comparing item to the list items using
equal?. The default value for equal? is equal?. When
equal? is invoked, item is the first argument.
(remove* items list [equal?]) PROCEDURE
Like remove, except that the first argument is a list of items
to remove, instead of a single item.
Calls remove with eq? as the comparison procedure.
Calls remove* with eq? as the comparison procedure.
Calls remove with eqv? as the comparison procedure.
Calls remove* with eqv? as the comparison procedure.
Returns a list that contains all but the first element of the
non-empty list l. (The rest procedure is a synonym for
cdr.)
Destructively modifies l so that its first element is v.
(The set-first! procedure is a synonym for set-car!
Destructively modifies l1 so that the rest of the list (after
the first element) is l2. (The set-rest! procedure is
a synonym for set-cdr!