DistinctUntilChanged overload for tuples with Equatable elements

[klop]

Short description of the issue:

There currently exists an overload of distinctUntilChanged on ObservableType which takes no arguments and is constrained to where E: Equatable. It simply implements the comparer by delegating to == on the Equatable element. This is useful since it lets us do:

Observable<String>().distinctUntilChanged()

rather than:

Observable<String>().distinctUntilChanged { $0 == $1 }

Unfortunately, we're not afforded the same syntactic brevity when dealing with tuples whose elements all conform to Equatable.

Expected outcome:

Ideally, we'd be able to write something like:

Observable
    .combineLatest(
        Observable<String>(),
        Observable<Int>()
    )
    .distinctUntilChanged()

What actually happens:

Since tuples cannot conform to protocols, we're faced with a compiler error:

error: referencing instance method 'distinctUntilChanged()' on 'ObservableType' requires that '(String, Int)' conform to 'Equatable'

To get around this, we can apply distinctUntilChanged() onto both of the inner observables instead:

Observable
    .combineLatest(
        Observable<String>().distinctUntilChanged(),
        Observable<Int>().distinctUntilChanged()
    )

Or alternatively, we can ad-hoc implement our own comparer:

Observable
    .combineLatest(
        Observable<String>(),
        Observable<Int>()
    )
    .distinctUntilChanged { $0 == $1 }

The last example works not because the tuple conforms to Equatable, but because the standard library provides us with implementations of == and != for tuples of up to arity 6 (see Tuple Comparison). It's also the only solution for observables that begin as tuples, rather than the result of combining multiple observables.

Proposed solution:

It's possible to implement an overload (or more, depending on arity) of distinctUntilChanged for tuples that similarly takes no arguments, and implements comparer using the == overloads for tuples.

For example, for 2-element tuples:

extension ObservableType {
    public func distinctUntilChanged<A: Equatable, B: Equatable>() -> Observable<(A, B)> where E == (A, B) {
        return self.distinctUntilChanged { $0 == $1 }
    }
}

Resulting in the code seen in "Expected outcome" being valid.

I'd be more than happy to make a pull request if the proposal is considered worthwhile. Thanks!

[klop]

Just found some relevant discussion here: #1747 (comment)

[freak4pc]

Hey @klop - thanks for sharing your thoughts :)

The discussion you linked to isn't relevant - it talks about Void not being Equatable - but that is a "finite" thing. e.g. Void is always Void, so I still think it's a fitting overload.

In my eyes, trying to go down the hole of Tuple conformance is out-of-scope for RxSwift and should possibly be either developed by individual developers who need it, or be part of something like RxSwiftExt.

In a "perfect world" - Swift compiler would have something like Conditional Conformance for Tuples that would have Tuples of Equatable be Equatable themselves. But until then, I really don't think this is a common enough problem to solve inside RxSwift.

Still leaving this open for discussion by others, but these are my $0.02.

Thanks!

[klop]

No problem @freak4pc, thanks for the response!

The part of the comment that seemed relevant to me was this one:

I would say that we need to be consistent and only provide Equality extensions. We can't provide tuple specific overloads for every single API where we have Equatable. This is not a realistic expectation.

If we accept this PR, how are you going to decide should we also add overload for (E) where E: Equatable, or (E1, E2) where E1: Equatable, E2: Equatable? At what number should we stop?

Should we also add these overloads for distinctUntilChanged operator?

Similarly, there'd have to be new logic for Recorded<Event<(A: Equatable, B: Equatable)>> etc.

That aside, I do see why this would be considered out of scope for RxSwift, especially if it isn't a common issue.

For anyone that's interested, here's the shortest form of distinctUntilChanged on observables of tuples with equatable elements.

Observable<(String, Int)>().distinctUntilChanged(==)

[freak4pc]

Thanks for the understanding - I think I'll close this for now but feel free to add another comment if you feel something here was unresolved.