Previous: Folding of Lists, Up: Lists [Contents][Index]
circular-list returns a circular list containing the given
objects. make-circular-list returns a circular list of
length k; if element is given, the returned list is filled
with it, otherwise the elements are unspecified.
This procedure is like list except that the returned list is
circular. circular-list could have been defined like this:
(define (circular-list . objects) (append! objects objects))
circular-list is compatible with SRFI 1, but extended
so that it can be called with no arguments.
Returns a newly allocated list consisting of the top-level elements of list in reverse order.
(reverse '(a b c)) ⇒ (c b a) (reverse '(a (b c) d (e (f)))) ⇒ ((e (f)) d (b c) a)
Returns a list consisting of the top-level elements of list in
reverse order. reverse! is like reverse, except that it
destructively modifies list. Because the result may not be
eqv? to list, it is desirable to do something like
(set! x (reverse! x)).
Sequence must be either a list or a vector. Key, if specified, must be a procedure of one argument that maps an element of sequence to a key fit for comparison by procedure; by default, key is the identity. Procedure must be a procedure of two arguments that defines a total ordering on the keys of sequence. In other words, if x and y are two distinct elements of sequence, then it must be the case that
(and (procedure (key x) (key y))
(procedure (key y) (key x)))
⇒ #f
If sequence is a list (vector), sort returns a newly
allocated list (vector) whose elements are those of sequence,
except that they are rearranged to be sorted in the order defined by
procedure and key.
So, for example, if the elements of sequence are numbers, and
procedure is <, then the resulting elements are sorted in
monotonically nondecreasing order.
Likewise, if procedure is >, the resulting elements are
sorted in monotonically nonincreasing order.
To be precise, if x and y are any two adjacent elements in
the result, where x precedes y, it is the case that
(procedure (key y) (key x))
⇒ #f
Two sorting algorithms are implemented: merge-sort and
quick-sort.
The procedure sort is an alias for merge-sort.
Merge-sort is stable, meaning that it preserves the order in
sequence of elements which are equivalent under procedure
and key; quick-sort is not stable, so it does not
guarantee this.
See also the definition of sort!.
(merge-sort '((2 . foo) (2 . bar) (1 . baz) (3 . quux)) < car) ⇒ ((1 . baz) (2 . foo) (2 . bar) (3 . quux)) (quick-sort '((2 . foo) (2 . bar) (1 . baz) (3 . quux)) < car) ⇒ ((1 . baz) (2 . bar) (2 . foo) (3 . quux))
Previous: Folding of Lists, Up: Lists [Contents][Index]