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.

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

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

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

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

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()"

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 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>

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?

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?