combinecommunity / rxswift-to-combine-cheatsheet Goto Github PK

Unable to push to repo, so I'll put an issue here. To refactor from RxSwift's combineLatest, I'm thinking of using Publishers.CombineLatest static init.

Combine's "replaceEmpty(with:)" appears to be "ifEmpty(default:)", but the sheet has them reversed.

Combine seems to have no operator fo "ifEmpty(switchTo:)", though it can be achieved with "replaceEmpty(with: publisher).switchToLatest()"

It's more like question not an issue. As I can see, in rxswift PublishSubject often used for binding + subscribing, e.g. the main idea of that class is to implement both Observer and Observable interfaces. In Combine this's no true because PassthroughSubject only implementes Pusblisher protocol and cannot be used as a subscriber. What do you think about that?

I believe the two in the title are equivalent. Shouldn't that be mentioned in the cheat sheet?

The cheatsheet currently suggests that RxSwift's buffer op is replaceable by the identically named buffer op in Combine. But that's not true and in actuality you'd be looking for Combine's collect with a grouping strategy. Could this be fixed?

Would be nice to visualize all the operators RxSwift (and common extensions) provide that Combine decided not to include thus far

import RxSwift

var values: [Int] = []

var inputSubject = PublishSubject<Observable<Int>>()

let disposable = inputSubject
  .merge(maxConcurrent: 2)
  .subscribe(onNext: { values.append($0) })

let a = PublishSubject<Int>()
let b = PublishSubject<Int>()

inputSubject.onNext(a)
inputSubject.onNext(b)
inputSubject.onNext(.just(3))

a.onNext(1)

values // [1]

b.onNext(2)

values // [1, 2]

b.onCompleted()
  
values // [1, 2, 3]

import Combine

var values: [Int] = []

var inputSubject = PassthroughSubject<AnyPublisher<Int, Never>, Never>()

let cancellable = inputSubject
  .flatMap(maxPublishers: .max(2), { $0 })
  .sink { values.append($0) }

let a = PassthroughSubject<Int, Never>()
let b = PassthroughSubject<Int, Never>()

inputSubject.send(a.eraseToAnyPublisher())
inputSubject.send(b.eraseToAnyPublisher())
inputSubject.send(Just(3).eraseToAnyPublisher())

a.send(1)

values // [1]

b.send(2)

values // [1, 2]

b.send(completion: .finished)
	
values // [1, 2] (seems like Just(3) was dropped)

Unless I'm mistaken, the cheat sheet should be updated to reflect this difference.

I noticed on in the code Optional.Publisher which was Publishers.Optional. Would this be like Maybe in rxSwift?

I think Publishers.Sequence is equal Observable.from.

Publishers.Sequence argument conform Sequence.
And Observable.from is the same

But Observable.of isn't the same.

    public static func from<Sequence>(_ sequence: Sequence, scheduler: RxSwift.ImmediateSchedulerType = CurrentThreadScheduler.instance) -> RxSwift.Observable<Self.Element> where Sequence : Sequence, Self.Element == Sequence.Element

    public static func of(_ elements: Self.Element..., scheduler: RxSwift.ImmediateSchedulerType = CurrentThreadScheduler.instance) -> RxSwift.Observable<Self.Element>

Probably that's because of beta, but their behavior is different now. (and combine looks buggy)
I just thought it might be important, cause people r watching this repo for combine tips :)

_ = Publishers.Sequence<[Int], E>(sequence: [1, 2, 3])
    .tryMap {
        if $0 == 2 {
            throw E()
        }
        return $0
    }
    .catch { _ in Publishers.Just(100) }
    .sink(receiveCompletion: { print($0) }, receiveValue: { print($0) })

// Expected: 1, 100, finished
// Actual: 1, 100, finished, 3

_ = Publishers.Sequence<[Int], E>(sequence: [1, 2, 3])
    .tryMap {
        if $0 == 2 {
            throw E()
        }
        return $0
    }
    .replaceError(with: 100)
    .sink(receiveCompletion: { print($0) }, receiveValue: { print($0) })
// Expected: 1, 100, finished
// Actual: 1, 100, finished, 3