Next: , Previous: , Up: Lists   [Contents][Index]

### 7.3 Selecting List Components

standard procedure: list? object
SRFI 1 procedure: proper-list? object

Returns `#t` if object is a proper list, otherwise returns `#f`. By definition, all proper lists have finite length and are terminated by the empty list. If object is a circular list, returns `#f`.

Any object satisfying this predicate will also satisfy exactly one of `pair?` or `null?`.

```(list? (list 'a 'b 'c))                 ⇒ #t
(list? (cons* 'a 'b 'c))                error→
(list? (circular-list 'a 'b 'c))        ⇒ #f
```
SRFI 1 procedure: circular-list? object

Returns `#t` if object is a circular list, otherwise returns `#f`.

```(circular-list? (list 'a 'b 'c))        ⇒ #f
(circular-list? (cons* 'a 'b 'c))       ⇒ #f
(circular-list? (circular-list 'a 'b 'c)) ⇒ #t
```
SRFI 1 procedure: dotted-list? object

Returns `#t` if object is an improper list, otherwise returns `#f`.

```(dotted-list? (list 'a 'b 'c))          ⇒ #f
(dotted-list? (cons* 'a 'b 'c))         ⇒ #t
(dotted-list? (circular-list 'a 'b 'c)) ⇒ #f
```
standard procedure: length list

Returns the length of list. Signals an error if list isn’t a proper list.

```(length (list 'a 'b 'c))                ⇒ 3
(length (cons* 'a 'b 'c))               error→
(length (circular-list 'a 'b 'c))       error→
```
SRFI 1 procedure: length+ clist

Clist must be a proper, dotted, or circular list. If clist is a circular list, returns `#f`, otherwise returns the number of pairs comprising the list (which is the same as the length for a proper list).

```(length+ (list 'a 'b 'c))               ⇒ 3
(length+ (cons* 'a 'b 'c))              ⇒ 2
(length+ (circular-list 'a 'b 'c))      ⇒ #f
```
standard procedure: null? object

Returns `#t` if object is the empty list; otherwise returns `#f`.

```(null? '())                             ⇒ #t
(null? (list 'a 'b 'c))                 ⇒ #f
(null? (cons* 'a 'b 'c))                ⇒ #f
(null? (circular-list 'a 'b 'c))        ⇒ #f
```
SRFI 1 procedure: null-list? list

List is a proper or circular list. This procedure returns `#t` if the argument is the empty list `()`, and `#f` if the argument is a pair. It is an error to pass this procedure any other value. This procedure is recommended as the termination condition for list-processing procedures that are not defined on dotted lists.

standard procedure: list-ref list k

Returns the kth element of list, using zero-origin indexing. The valid indexes of a list are the exact non-negative integers less than the length of the list. The first element of a list has index `0`, the second has index `1`, and so on.

```(list-ref '(a b c d) 2)                 ⇒ c
(list-ref '(a b c d)
(exact (round 1.8)))
⇒ c
```

`(list-ref list k)` is equivalent to `(car (drop list k))`.

SRFI 1 procedure: first list
SRFI 1 procedure: second list
SRFI 1 procedure: third list
SRFI 1 procedure: fourth list
SRFI 1 procedure: fifth list
SRFI 1 procedure: sixth list
SRFI 1 procedure: seventh list
SRFI 1 procedure: eighth list
SRFI 1 procedure: ninth list
SRFI 1 procedure: tenth list

Returns the specified element of list. It is an error if list is not long enough to contain the specified element (for example, if the argument to `seventh` is a list that contains only six elements).

Next: , Previous: , Up: Lists   [Contents][Index]