A modern programming language that makes developers happier.

kotlinlang

I'm wondering about the rationale for `Iterable.all` returning `true` when called on an empty List:
```val list = emptyList&lt;Boolean&gt;()
list.all { it } // true
list.none { it } // true
list.any {it } // false```

Another way of thinking about it is that "all items are X" is equivalent to "there is no item that is not X".

Yes, but this definition then wouldn't apply to `none` in the same way :wink:

Counter-question, why should it not return `true`?
All elements in the list are satisfying the predicate.

`none` and `any` with lambda argument are consistent with the no-argument versions:
```list.none() == true
list.any() == false```
because they check if the list is empty/not empty.

I think the question is quite philosophical in the end
"if there are no elements, can we say that they satisfy the predicate?"
We can say for sure "There are no elements that don't satisfy the predicate"

But you couldn't apply the same logical negation to the current behavior of `fun &lt;T&gt; none(predicate: T -&gt; Boolean)`

None seems to answer ‘there are no elements that do satisfy the predicate’

True, it's actually not the opposite of `all`.

It's not really a philosophical question.
All elements in the list satisfy the predicate.
That there is no actual element that could unsatisfy is not relevant.
All elements that *are* in the list satisfy the predicate.

Also, if you wanted `all` to return false for empty lists, whatever programming language you use, you would have to have special treatment for empty lists. The logical way is to return true, because you iterate the list and return false if you find an element that doesn't satisfy the predicate; if you reach the end of the iteration, you return true. This is the case in most languages, not just Kotlin.

Using `all` rather to check if there is at least one element that doesn't fulfill the predicate.

And not to check "do I have any elements and do they all fulfill the predicate"

Sometimes I wonder if they should just leave a link to this wiki article in the `.all()` docstring <https://en.wikipedia.org/wiki/Vacuous_truth>

Thanks Shawn, I was literally writing that this has little to do with programming, but it's just how logic/math defines this stuff

Thanks for the article! That gives a good context for this decision.

```(list + x).any() == list.any() || x
(list + x).all() == list.all() &amp;&amp; x
(list + x).none() == list.none() &amp;&amp; !x
```
these identities work for lists of all sizes; if you set `list = emptyList()` and try different values of `x`, it is clear there is only one reasonable value for those functions on an empty list