RxSwift: Deep Cuts - Speaker Deck

Slide 1

Slide 1 text

RxSwift:   Deep Cuts Krzysztof Siejkowski

Slide 2

Slide 2 text

Alex is an iOS developer

Slide 3

Slide 3 text

Reactive programming

Slide 4

Slide 4 text

RxSwift ❤

Slide 5

Slide 5 text

No content

Slide 6

Slide 6 text

dataProvider.refreshData() .subscribe( onNext: { [weak self] in self!?.update(with: $0) }, onError: { [weak self] in if let error = $0 as? ReasonableError { self!?.showUserMessage(with: error.reason) } } ) .disposed(by: disposeBag)

Slide 7

Slide 7 text

Slide 8

Slide 8 text

Slide 9

Slide 9 text

Slide 10

Slide 10 text

Slide 11

Slide 11 text

Slide 12

Slide 12 text

#1 What references   does it carry?

Slide 13

Slide 13 text

Observable .just(42) Just

Slide 14

Slide 14 text

Observable .just(42) .filter { $0 > 30 } Just Filter

Slide 15

Slide 15 text

Observable .just(42) .filter { $0 > 30 } .map { “\($0)” } Just Filter Map

Slide 16

Slide 16 text

Observable .just(42) .filter { $0 > 30 } .map { “\($0)” } .distinctUntilChanged { $0 !== $1 } Just Filter Map Distinct UntilChanged

Slide 17

Slide 17 text

let observable: Observable = Observable .just(42) .filter { $0 > 30 } .map { “\($0)” } .distinctUntilChanged { $0 !== $1 } Just Filter Map observable observable

Slide 18

Slide 18 text

environment Observable .just(42) .filter { $0 > 30 } .map { “\($0)” } .distinctUntilChanged { $0 !== $1 } Just Filter Map Distinct UntilChanged filter closure compare closure map closure

Slide 19

Slide 19 text

Observable .just(42) .filter { $0 > 30 } .map { “\($0)” } .distinctUntilChanged { $0 !== $1 } .subscribe { print($0) } Just Filter Map Distinct UntilChanged filter closure compare closure map closure Just Sink Filter Sink Map Sink DUC Sink

Slide 20

Slide 20 text

Slide 21

Slide 21 text

Slide 22

Slide 22 text

filter closure compare closure map closure Just Sink Filter Sink Map Sink DUC Sink Observer Just Sink Disposer Filter Sink Disposer Map Sink Disposer DUC Sink Disposer Observable .just(42) .filter { $0 > 30 } .map { “\($0)” } .distinctUntilChanged { $0 !== $1 } .subscribe { print($0) }

Slide 23

Slide 23 text

reference cycles filter closure compare closure map closure Just Sink Filter Sink Map Sink DUC Sink Observer Just Sink Disposer Filter Sink Disposer Map Sink Disposer DUC Sink Disposer

Slide 24

Slide 24 text

filter closure compare closure map closure Just Sink Filter Sink Map Sink DUC Sink Observer Just Sink Disposer Filter Sink Disposer Map Sink Disposer disposable let disposable: Disposable = Observable .just(42) .filter { $0 > 30 } .map { “\($0)” } .distinctUntilChanged { $0 !== $1 } .subscribe { print($0) }

Slide 25

Slide 25 text

disposable .dispose() filter closure compare closure map closure Just Sink Filter Sink Map Sink DUC Sink Observer Just Sink Disposer Filter Sink Disposer Map Sink Disposer disposable

Slide 26

Slide 26 text

.dispose() — called externally   on subscription disposable — called internally   when event stream ends

Slide 27

Slide 27 text

filter closure compare closure map closure Just Sink Filter Sink Map Sink DUC Sink Observer Just Sink Disposer Filter Sink Disposer Map Sink Disposer disposable observe closure let disposable = Observable .just(42) .filter { $0 > 30 } .map { “\($0)” } .distinctUntilChanged { $0 !== $1 } .subscribe { print($0) }

Slide 28

Slide 28 text

environment let disposable = Observable .just(42) .filter { $0 > 30 } .map { “\($0)” } .distinctUntilChanged { $0 !== $1 } .subscribe { print($0) } filter closure compare closure map closure Just Sink Filter Sink Map Sink DUC Sink Observer Just Sink Disposer Filter Sink Disposer Map Sink Disposer disposable observe closure

Slide 29

Slide 29 text

Memory leaks and extended lifetime

Slide 30

Slide 30 text

Dispose your subscriptions

Slide 31

Slide 31 text

Watch your references

Slide 32

Slide 32 text

observable .map { [weak self] in self!?.transform($0) } .subscribe { [weak self] in self!?.react(to: $0) } observable .map { [unowned self] in self.transform($0) } .subscribe { [unowned self] in self.react(to: $0) } .disposed( by: self.disposeBag )

Slide 33

Slide 33 text

!// instance method func foo(_ bar: Int) !-> Int !// instance scope Observable.just(42) .map(foo) !// instance method func foo(_ bar: Int) !-> Int !// instance scope Observable.just(42) .map { self.foo($0) }

Slide 34

Slide 34 text

Slide 35

Slide 35 text

dataProvider.refreshData() .subscribe( onNext: { [unowned self] in self.update(with: $0) }, onError: { [unowned self] in if let error = $0 as? ReasonableError { self.showUserMessage(with: error.reason) } } ) .disposed(by: disposeBag)

Slide 36

Slide 36 text

Slide 37

Slide 37 text

#2 What thread does it do the work on?

Slide 38

Slide 38 text

Schedulers define context of work execution

Slide 39

Slide 39 text

ImmediateSchedulerType func schedule( _ state: StateType, action: @escaping (StateType) !-> Disposable ) !-> Disposable 

Slide 40

Slide 40 text

MainScheduler let mainQueue = DispatchQueue.main !// simplified essence of schedule method if DispatchQueue.isMain { action(state) } else { mainQueue.async { action(state) } }

Slide 41

Slide 41 text

SerialDispatchQueueScheduler !// internal serial dispatch queue of given properties let queue = DispatchQueue.global(qos: qos.qosClass) !// simplified essence of schedule method queue.async { action(state) }

Slide 42

Slide 42 text

OperationQueueScheduler !// operation queue provided by client in the initializer let operationQueue: OperationQueue !// simplified essence of schedule method operationQueue.addOperation( BlockOperation { action(state)) } )

Slide 43

Slide 43 text

Also in schedulers • QOS • serial / concurrent • immediate / delayed • driven by client

Slide 44

Slide 44 text

Scheduler-using operators interval(1, scheduler) delay(2, scheduler) throttle(3, scheduler)

Slide 45

Slide 45 text

Scheduler-agnostic operators map { foo($0) } flatMap { bar($0) } filter { $0 !== wanted }

Slide 46

Slide 46 text

Scheduler-deﬁning operators observeOn(scheduler) subscribeOn(scheduler)

Slide 47

Slide 47 text

Observable .just(42) .filter { $0 > 33 } .map { "\($0)" } .subscribe { print($0) } .disposed(by: disposeBag) Subscription thread

Slide 48

Slide 48 text

Observable .just(42) .observeOn(greenScheduler) .filter { $0 > 33 } .map { "\($0)" } .subscribe { print($0) } .disposed(by: disposeBag) Subscription thread Green scheduler

Slide 49

Slide 49 text

Observable .just(42) .observeOn(greenScheduler) .filter { $0 > 33 } .observeOn(redScheduler) .map { "\($0)" } .observeOn(greenScheduler) .subscribe { print($0) } .disposed(by: disposeBag) Subscription thread Red scheduler Green scheduler Green scheduler

Slide 50

Slide 50 text

Observable .just(42) .observeOn(greenScheduler) .filter { $0 > 33 } .observeOn(redScheduler) .subscribeOn(blueScheduler) .map { "\($0)" } .observeOn(greenScheduler) .subscribe { print($0) } .disposed(by: disposeBag) Blue scheduler Red scheduler Green scheduler Green scheduler

Slide 51

Slide 51 text

Observable .just(42) .observeOn(greenScheduler) .filter { $0 > 33 } .subscribeOn(blueScheduler) .observeOn(redScheduler) .subscribeOn(redScheduler) .map { "\($0)" } .observeOn(greenScheduler) .subscribeOn(greenScheduler) .subscribe { print($0) } .disposed(by: disposeBag) Blue scheduler Red scheduler Green scheduler Green scheduler

Slide 52

Slide 52 text

Observable .just( 42, scheduler: blueScheduler ) .observeOn(greenScheduler) .filter { $0 > 33 } .observeOn(redScheduler) .subscribeOn(redScheduler) .map { "\($0)" } .observeOn(greenScheduler) .subscribe { print($0) } .disposed(by: disposeBag) Blue scheduler Red scheduler Green scheduler Green scheduler

Slide 53

Slide 53 text

Schedulers used for: • generation • internal work

Slide 54

Slide 54 text

Schedule-using for generation !// Scheduler to send elements on. .fromScheduled([1, 2, 3], greenScheduler) !// Scheduler to run the producer loop on. .repeatElement(1, blueScheduler) !// Scheduler to run the timer on. .interval(1, redScheduler)

Slide 55

Slide 55 text

Schedule-using for internal work !// Scheduler to run the throttle timers on. .throttle(1, blueScheduler) !// Scheduler to run the subscription delay timer on. .delay(1, greenScheduler) !// Scheduler to run buffering timers on. .buffer(timeSpan: 1, count: 3, scheduler: redScheduler)

Slide 56

Slide 56 text

Delivery thread may change between events

Slide 57

Slide 57 text

Observable .merge([ Observable.interval(3, redScheduler), Observable.interval(5, greenScheduler), ]) .subscribe { [unowned self] in !// sometimes red, sometimes green self.work(with: $0) } .disposed(by: disposeBag)

Slide 58

Slide 58 text

Read the docs   and   the source code

Slide 59

Slide 59 text

When in doubt, ensure with observeOn

Slide 60

Slide 60 text

RxCocoa traits guarantee MainScheduler

Slide 61

Slide 61 text

dataProvider.refreshData() .observeOn(MainScheduler.instance) .subscribe( onNext: { [unowned self] in self.update(with: $0) }, onError: { [unowned self] in if let error = $0 as? ReasonableError { self.showUserMessage(with: error.reason) } } ) .disposed(by: disposeBag)

Slide 62

Slide 62 text

Slide 63

Slide 63 text

#3 What protocol does it follow?

Slide 64

Slide 64 text

.next(data) .completed .error(error)

Slide 65

Slide 65 text

Different protocols may need different subscriptions

Slide 66

Slide 66 text

Does it finish?

Slide 67

Slide 67 text

Finishing !// you may ignore disposable (though I recommend not to!) _ = observable .subscribe(onNext: { [weak self] in self!?.work(on: $0) })

Slide 68

Slide 68 text

Not ﬁnishing let disposable = observable .subscribe(onNext: { [weak self] in self!?.work(on: $0) }) !// ensure subscription disposing disposable.dispose() disposable.disposed(by: disposeBag)

Slide 69

Slide 69 text

How long   does it last?

Slide 70

Slide 70 text

One-off let serial = SerialDisposable() !// call each time you want the fresh data func fetchFreshData() { serial.disposable = observable .subscribe(onNext: { [unowned self] in self.work(on: $0) }) }

Slide 71

Slide 71 text

Updating let disposeBag = DisposeBag() !// call only once in the object lifetime func listenForFreshData() { observable .subscribe(onNext: { [unowned self] in self.work(on: $0) }) .disposed(by: disposeBag) }

Slide 72

Slide 72 text

When and how does it   start emitting?

Slide 73

Slide 73 text

Immediately & synchronously !// if not ready to handle data at the `subscribe` time dataProvider .data() .skip(1) .subscribe(onNext: { [unowned self] in self.work(on: $0) }) .disposed(by: disposeBag)

Slide 74

Slide 74 text

After some time & asynchronously !// provide separate method for fetching initial data let initialData = dataProvider.getInitialData() dataProvider .dataUpdates() .subscribe(onNext: { [unowned self] in self.work(on: $0) }) .disposed(by: disposeBag)

Slide 75

Slide 75 text

Does it cache   the events?

Slide 76

Slide 76 text

Not caching let observable = dataProvider .fetchHugeAmountOfDataFromNetwork() !// costly network request with fresh data observable.subscribe() !// costly network request with fresh data observable.subscribe()

Slide 77

Slide 77 text

Caching let observable = dataProvider .fetchHugeAmountOfDataFromNetwork() .shareReplay(1) !// costly network request with fresh data observable.subscribe() !// no network refresh but also old data observable.subscribe()

Slide 78

Slide 78 text

Also in protocols • error types • time relations • many more

Slide 79

Slide 79 text

Expose the protocol via the type system

Slide 80

Slide 80 text

RxCocoa traits • Driver • Signal • ControlProperty

Slide 81

Slide 81 text

RxSwift traits • Single • Completable • Maybe

Slide 82

Slide 82 text

Document the protocol

Slide 83

Slide 83 text

!/* Returns an Observable that emits at most three times, starting with the first event emitted immediately and synchronously upon subscription. Times of other two events are not guaranteed. May not complete, but never errors out. Doesn’t cache any data. !*/ public func thirdTimeLucky() !-> Observable

Slide 84

Slide 84 text

Conventionalize the protocol

Slide 85

Slide 85 text

final class DataProvider { private let proxySubject = PublishSubject() var data: Observable { return proxySubject.asObservable() } func refreshData() !-> Observable { return networkService .requestData() .do(onNext: { proxySubject.onNext($0) } .map { _ in } }