Warning: This is the manual of the legacy Guile 2.2 series. You may want to read the manual of the current stable series instead.

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