Construction of Lists - MIT/GNU Scheme 9.0.1
Description: MIT/GNU Scheme 9.0.1

Next: Selecting List Components, Previous: Pairs, Up: Lists

### 7.2 Construction of Lists

— procedure: list object ...

> Returns a list of its arguments.

>               (list 'a (+ 3 4) 'c)                    ⇒ (a 7 c)
>               (list)                                  ⇒ ()

> These expressions are equivalent:

>               (list obj1 obj2 ... objN)
>               (cons obj1 (cons obj2 ... (cons objN '()) ...))

— procedure: make-list k [element]

> (SRFI 1) This procedure returns a newly allocated list of length k, whose elements are all element. If element is not supplied, it defaults to the empty list.

>               (make-list 4 'c)                        ⇒ (c c c c)

— procedure: cons* object object ...

> (SRFI 1) `cons*` is similar to `list`, except that `cons*` conses together the last two arguments rather than consing the last argument with the empty list. If the last argument is not a list the result is an improper list. If the last argument is a list, the result is a list consisting of the initial arguments and all of the items in the final argument. If there is only one argument, the result is the argument.

>               (cons* 'a 'b 'c)                        ⇒ (a b . c)
>               (cons* 'a 'b '(c d))                    ⇒ (a b c d)
>               (cons* 'a)                              ⇒ a

> These expressions are equivalent:

>               (cons* obj1 obj2 ... objN-1 objN)
>               (cons obj1 (cons obj2 ... (cons objN-1 objN) ...))

— procedure: list-tabulate k init-proc
— procedure: make-initialized-list k init-proc

> Returns a k-element list. Element i of the list, where 0 <= i < k, is produced by (init-proc i). No guarantee is made about the dynamic order in which init-proc is applied to these indices.

>               (list-tabulate 4 values) => (0 1 2 3)

> `list-tabulate` is defined by SRFI 1.

— procedure: list-copy list

> (SRFI 1) Returns a newly allocated copy of list. This copies each of the pairs comprising list. This could have been defined by

>               (define (list-copy list)
>                 (if (null? list)
>                     '()
>                     (cons (car list)
>                           (list-copy (cdr list)))))

— procedure: iota count [start [step]]

> (SRFI 1) Returns a list containing the elements

>               (start start+step ... start+(count-1)*step)

> Count must be an exact non-negative integer, while start and step can be any numbers. The start and step parameters default to 0 and 1, respectively.

>               (iota 5) ⇒ (0 1 2 3 4)
>               (iota 5 0 -0.1) ⇒ (0 -0.1 -0.2 -0.3 -0.4)

— procedure: vector->list vector
— procedure: subvector->list vector start end

> `vector->list` returns a newly allocated list of the elements of vector.
> `subvector->list` returns a newly allocated list of the elements of the given subvector. The inverse of `vector->list` is `list->vector`.

>               (vector->list '#(dah dah didah))        ⇒ (dah dah didah)

— procedure: string->list string
— procedure: substring->list string start end

> `string->list` returns a newly allocated list of the character elements of string.
> `substring->list` returns a newly allocated list of the character elements of the given substring. The inverse of `string->list` is `list->string`.

>               (string->list "abcd")                   ⇒ (#\a #\b #\c #\d)
>               (substring->list "abcdef" 1 3)          ⇒ (#\b #\c)