[Pitch] `Distinguishable` protocol for Quick Comparisons

nnnnnnnn · April 11, 2025, 9:11pm

One data point is that Sequence actually has a semi-hidden customization point that uses the Bool? tripartite result for containment checks: _customContainsEquatableElement:

github.com/swiftlang/swift

stdlib/public/core/Sequence.swift

main


      
          /// Sequences whose `Element` is `Equatable` and that are able to quickly
          /// check if they contain a particular value can implement this requirement
          /// to speed up the standard `contains` method.
          ///
          /// The default implementation returns nil, indicating that `contains` should
          /// fall back to the standard linear search algorithm.
          ///
          /// `Sequence` and `Collection` algorithms other than `contains` itself may
          /// adapt their behavior based on whether or not this function returns nil.
          /// For example, a generic algorithm that needs to do containment checks for
          /// many different values may decide not to copy items into a temporary `Set`
          /// if it sees that the sequence implements this method. Therefore, sequences
          /// should only implement this method if they can do it in better than linear
          /// time.
          ///
          /// For sequences that are destructively consumed by iteration, calling this
          /// method must not consume any elements. (Such sequences usually leave this
          /// method with its default, `nil`-returning implementation, which trivially
          /// satisfies this requirement.)
          ///

This file has been truncated. show original

This method uses an optional result because not every collection can provide a speed increase over a linear search, like Array. For collections that can, like Set or Range, the implementation of this method lets them provide fast containment checks even in generic contexts.