# 13 Jul 2024

# The Empty Collection Conundrum: Are All Elements the Same When There Are None?

## The Problem at Hand

Imagine you’re writing a function to check if all items in a list are the same. It might look something like this:

```
boolean allSame(List<?> items) {
if (items.isEmpty()) {
return ?; // This is our puzzle
}
Object first = items.get(0);
for (Object item : items) {
if (item != null && !first.equals(item)) {
return false;
}
}
return true;
}
```

This function works fine for non-empty lists, but what about empty ones? Should we say all elements are the same (return true), or that they’re not (return false)?

## The “King of France” Paradox

This situation is reminiscent of the classic logical puzzle: “Is the current king of France bald?” The trick is, France doesn’t have a king! So how can we answer?

In logic, we often treat such statements as vacuously true. Why? Because if we say “All kings of France are bald,” we’re not actually making any false statements - there are no kings of France to be not bald!

## Mathematical Thinking

Let’s get a bit mathy for a moment. If we call our function `f`

, and a list `L`

, we can say:

```
If f(L) = true, then f(L - {x}) = true, for any x in L
```

In plain English: If all elements in a list are the same, removing any element shouldn’t change that fact.

Now, if we keep removing elements, we’ll eventually end up with an empty list. Following our logic, `f([])`

should be true.

## Why This Matters

Choosing to return true for empty lists isn’t just philosophical navel-gazing. It has practical benefits:

**Consistency**: Our function behaves predictably for all lists, even empty ones.**Mathematical soundness**: It aligns with principles of logic and set theory.**Easier testing**: It gives us a clear expectation for the empty list case.

## Putting It All Together

Here’s how our final function might look:

```
boolean allSame(List<?> items) {
if (items.isEmpty()) {
return true; // Vacuously true
}
Object first = items.get(0);
for (Object item : items) {
if (item != null && !first.equals(item)) {
return false;
}
}
return true;
}
```

## Wrapping Up

When designing functions that work with collections, it’s crucial to consider edge cases like empty lists. By applying logical principles, we can create functions that are not only practical but also mathematically sound.

Remember to document your reasoning. A comment like “Returns true for empty lists (vacuously true)” can save future developers (including yourself!) a lot of head-scratching.