— procedure: sublist list start end

Start and end must be exact integers satisfying

          0 <= start <= end <= (length list)

sublist returns a newly allocated list formed from the elements of list beginning at index start (inclusive) and ending at end (exclusive).

— procedure: list-head list k

Returns a newly allocated list consisting of the first k elements of list. K must not be greater than the length of list.

We could have defined list-head this way:

          (define (list-head list k)
            (sublist list 0 k))

— procedure: list-tail list k

Returns the sublist of list obtained by omitting the first k elements. The result, if it is not the empty list, shares structure with list. K must not be greater than the length of list.

— procedure: append list ...

Returns a list consisting of the elements of the first list followed by the elements of the other lists.

          (append '(x) '(y))                       (x y)
          (append '(a) '(b c d))                   (a b c d)
          (append '(a (b)) '((c)))                 (a (b) (c))
          (append)                                 ()

The resulting list is always newly allocated, except that it shares structure with the last list argument. The last argument may actually be any object; an improper list results if the last argument is not a proper list.

          (append '(a b) '(c . d))                 (a b c . d)
          (append '() 'a)                          a

— procedure: append! list ...

Returns a list that is the argument lists concatenated together. The arguments are changed rather than copied. (Compare this with append, which copies arguments rather than destroying them.) For example:

          (define x '(a b c))
          (define y '(d e f))
          (define z '(g h))
          (append! x y z)                          (a b c d e f g h)
          x                                        (a b c d e f g h)
          y                                        (d e f g h)
          z                                        (g h)

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