allSatisfy vs contains in performance terms

Using Swift
1

I have the following scenario: I want to process an array of boolean values by checking if all values match true.

For that, I've used array.allSatisfy({ $0 == true }) but I was thinking about using !array.contains(false) because they return the same result but I don't know if there's any difference in performance (readibility is out of question because it's evident that allSatisfy is more readable).

One famous LLM said that contains is better than allSatisfy because it stops in the first mismatch detected but I have strong doubts about this, because both are O(n) according to documentation and it's expected that allSatisfy does the same mechanism.

So the question is: Are they have the same performance or is there any notable difference? I think that they perfom the same way or, if not, the difference in performance is neglible.

Best regards.

2

Intuitively, contains would be more performant as it does not need to invoke a function for each element. That could also lead to better compiler optimizations.

Both allSatisfy and contains will stop their search as soon as a counterexample/example is found.

I might add that contains also reads better to me, but that’s just personal preference.

2 Likes
3

In optimized builds, they have the same performance.

If you care about nanoseconds, measure actual performance, and update measurements every time you update compiler.

1 Like
4

If you check the implementation, you'll see that allSatisfy just calls contains.

2 Likes
5

allSatisfy calls contains(where predicate:), not contains(_ element:)

6

Well yes, since allSatisfy takes a predicate as an argument.

I should have been clearer.

7

I've read the replies and checked the implementation mentioned and I arrived to the next conclusions:

  • allSatisfy({}) -> calls contains(where: {}) with inverting the logic of predicate and result. (As mentioned in previous post)
  • contains(_ element:) also calls contains(where: {}) contains(_ element:) implementation
  • If Sequence is composed of Equatable elements and capable of direct access to element, contains(_ element:) will use _customContainsEquatableElement to retrieve the result. Array, as I see, does not have implemented this method, so will behave like contains(where: {}).

In short: all of them have the same performance in Array and only will get improvement using contains(_ element:) if using another type of Sequence with Equatable elements.

Thank you everyone.