[erlang-questions] lists:all/2 unexpected result for the empty list

[Richard O'Keefe]

On 20/07/2011, at 1:09 PM, Michael Truog wrote:
> The choice of true for lists:all/2 with an empty list still seems arbitrary to me.

It is anything but!

Let's switch to Haskell for a minute.

foldr f e [] = e
foldr f e (x:xs) = f x (foldr f e xs)

  That is, foldr f e [x1,x2,...,xn] = f x1 (f x2 ... (f xn e) ...)

  Note that for uniformity, foldr f e [x] has to be f x e.

and = foldr (&&) True
or  = foldr (||) False

  "and" tests whether all the elements of a list are true
  "or"  tests whether at least one element of a list is true

  Note that *no* value other than True could be used for "and";
  *no* value other than False could be used for "or".  Try the
  opposite truth value and it just plain won't work.

map f [] = []
map f (x:xs) = f x : map f xs

all p = and . map p
any p = or  . map p

  That is, apply a predicate p to all the elements of a list,
  and then check whether all (or any) of the results are true.

  Expand out these definitions and you get

all p [] = True
all p (x:xs) = p x && all p xs

any p [] = False
any p (x:xs) = p x || any p xs

  Once again, plugging anything other than True into the base
  case of "all" could not possibly work.

aristotelian_all p [] = False
aristotelian_all p (x:xs) = all p (x:xs)

  or

aristotelian_all p xs = not (null xs) && all p xs

  and however you slice it, the unmotivated requirement to
  return False for any empty list just makes the code
  longer and less comprehensible.  You should see what
  horrors it inflicts on the code that USES it!

>  However, I don't think there is a good argument for the choice being wrong.

You would have to convince every mathematician and logician on the
planet that they were doing quantifiers wrong.

The documentation probably didn't say anything about the issue
because it doesn't make any more sense for all(P, []) to return
false than for sum([]) to return -792.