MIT Scheme Reference - Miscellaneous List Operations

Go to the previous, next section.

Miscellaneous List Operations

procedure+: circular-list object ...

procedure+: make-circular-list k [element]

These procedures are like list and make-list, respectively, except that the returned lists are circular. circular-list could have been defined like this:

(define (circular-list . objects)
  (append! objects objects))

procedure: reverse list

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)

procedure+: reverse! list

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)).

procedure+: last-pair list

Returns the last pair in list, which may be an improper list. last-pair could have been defined this way:

(define last-pair
  (lambda (x)
    (if (pair? (cdr x))
        (last-pair (cdr x))
        x)))

procedure+: except-last-pair list

procedure+: except-last-pair! list

These procedures remove the last pair from list. List may be an improper list, except that it must consist of at least one pair. except-last-pair returns a newly allocated copy of list that omits the last pair. except-last-pair! destructively removes the last pair from list and returns list. If the cdr of list is not a pair, the empty list is returned by either procedure.

procedure+: sort sequence procedure

Sequence must be either a list or a vector. Procedure must be a procedure of two arguments that defines a total ordering on the elements of sequence. In other words, if x and y are two distinct elements of sequence, then it must be the case that

(and (procedure x y)
     (procedure y 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. 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 y x)
     =>  #f