Functional Programming: what is an “improper list”?

Question

Could somebody explain what an \"improper list\" is?

Note: Thanks to all ! All you guys rock!

Answer 1

To understand what an improper list is, you must first understand the definition of a proper list.

Specifically, the "neat discovery" of lists is that you can represent a list using only forms with a fixed number of elements, viz:

;; a list is either 
;; - empty, or
;; - (cons v l), where v is a value and l is a list.

This "data definition" (using the terms of How To Design Programs) has all kinds of nice properties. One of the nicest is that if we define the behavior or meaning of a function on each "branch" of the data definition, we're guaranteed not to miss a case. More significantly, structures like this generally lead to nice clean recursive solutions.

The classic "length" example:

(define (length l)
  (cond [(empty? l) 0]
        [else (+ 1 (length (rest l))]))

Of course, everything's prettier in Haskell:

length []    = 0
length (f:r) = 1 + length r

So, what does this have to do with improper lists?

Well, an improper list uses this data definition, instead:

;; an improper list is either
;; - a value, or
;; - (cons v l), where v is a value and l is an improper list

The problem is that this definition leads to ambiguity. In particular, the first and second cases overlap. Suppose I define "length" for an improper list thusly:

(define (length l)
  (cond [(cons? l) (+ 1 (length (rest l)))]
        [else 1]))

The problem is that I've destroyed the nice property that if I take two values and put them into an improper list with (cons a b), the result has length two. To see why, suppose I consider the values (cons 3 4) and (cons 4 5). The result is (cons (cons 3 4) (cons 4 5)), which may be interpreted either as the improper list containing (cons 3 4) and (cons 4 5), or as the improper list containing (cons 3 4), 4, and 5.

In a language with a more restrictive type system (e.g. Haskell), the notion of an "improper list" doesn't make quite as much sense; you could interpret it as a datatype whose base case has two things in it, which is probably not what you want, either.