#### 7.5.3.2 Predicates

The procedures in this section test specific properties of lists.

Scheme Procedure: proper-list? obj

Return `#t` if obj is a proper list, or `#f` otherwise. This is the same as the core `list?` (see List Predicates).

A proper list is a list which ends with the empty list `()` in the usual way. The empty list `()` itself is a proper list too.

```(proper-list? '(1 2 3))  ⇒ #t
(proper-list? '())       ⇒ #t
```
Scheme Procedure: circular-list? obj

Return `#t` if obj is a circular list, or `#f` otherwise.

A circular list is a list where at some point the `cdr` refers back to a previous pair in the list (either the start or some later point), so that following the `cdr`s takes you around in a circle, with no end.

```(define x (list 1 2 3 4))
(set-cdr! (last-pair x) (cddr x))
x ⇒ (1 2 3 4 3 4 3 4 ...)
(circular-list? x)  ⇒ #t
```
Scheme Procedure: dotted-list? obj

Return `#t` if obj is a dotted list, or `#f` otherwise.

A dotted list is a list where the `cdr` of the last pair is not the empty list `()`. Any non-pair obj is also considered a dotted list, with length zero.

```(dotted-list? '(1 2 . 3))  ⇒ #t
(dotted-list? 99)          ⇒ #t
```

It will be noted that any Scheme object passes exactly one of the above three tests `proper-list?`, `circular-list?` and `dotted-list?`. Non-lists are `dotted-list?`, finite lists are either `proper-list?` or `dotted-list?`, and infinite lists are `circular-list?`.

Scheme Procedure: null-list? lst

Return `#t` if lst is the empty list `()`, `#f` otherwise. If something else than a proper or circular list is passed as lst, an error is signalled. This procedure is recommended for checking for the end of a list in contexts where dotted lists are not allowed.

Scheme Procedure: not-pair? obj

Return `#t` is obj is not a pair, `#f` otherwise. This is shorthand notation `(not (pair? obj))` and is supposed to be used for end-of-list checking in contexts where dotted lists are allowed.

Scheme Procedure: list= elt= list1 …

Return `#t` if all argument lists are equal, `#f` otherwise. List equality is determined by testing whether all lists have the same length and the corresponding elements are equal in the sense of the equality predicate elt=. If no or only one list is given, `#t` is returned.