RxSwift to Combine

뱅크샐러드박보영
RxSwift to Combine
feat. SwiftUI

Introduce
Customize handling
of asynchronous events
by combining event-processing operators.
https://developer.apple.com/documentation/combine

Introduce
Combine declares publishers to
expose values that can change over
time, and subscribers to receive
those values from the publishers.

Introduce
By adopting Combine, you’ll make your
code easier to read and maintain, by
centralizing your event-processing code
and eliminating troublesome techniques
like nested closures and convention-based
callbacks.

Index
개념
비교하기
예제로
확인하기
정리

Asynchronous Interfaces
•Target/Action
•Notification Center
•URLSession
•KVO
•Ad-hoc callbacks
왜? Combine
https://developer.apple.com/videos/play/wwdc2019/722/

A unified declarative API for
processing values over time
Combine은,

Combine 핵심 요소
Publishers Subscribers Operators

Combine vs. RxSwift
Publishers Subscribers Operators
Observable Observer Operators

Publishers
/Subscribers
Observable
/Observer
Operator Operator
Combine vs. RxSwift

Publishers
/Subscribers
Observable
/Observer
Subject
Operator Operator
Cancellable
Subscribe(on:)
Combine vs. RxSwift

Publishers
/Subscribers
Observable
/Observer
Subject
Operator
Subject
Operator
Cancellable
Subscribe(on:)
Combine vs. RxSwift

Publishers
/Subscribers
Observable
/Observer
Subject
Operator
Subject
Operator
Cancellable Disposable
Subscribe(on:)
Combine vs. RxSwift

Publishers
/Subscribers
Observable
/Observer
Subject
Operator
Subject
Operator
subscribe(on:) subscribeOn(_:)
Combine vs. RxSwift

Publisher vs. Observable
• AnyPublisher •Observable

class Observable: ObservableType { }
struct AnyPublisher: Publisher { }
protocol Publisher { }⋯
⋯
⋯

protocol Publisher { }
⋯
⋯
⋯

• AnyPublisher
• Value Type
•Observable
•Reference Type
⋯
⋯

• AnyPublisher
• Value Type
• Output(Data type)
• Failure(Error type)
•Observable
•Reference Type
•Element(Data type)
•❌

• AnyPublisher
• Value Type
•Observable
•Reference Type
•❌
AnyPublisher<String, Error> Observable<Result<String, Error>>

• AnyPublisher
• Value Type
•Observable
•Reference Type
•❌
AnyPublisher<String, Error>
AnyPublisher<String, Never>
Observable<Result<String, Error>>
Observable<String>

Operators, RxSwift Only
Combine에는 없는 Operators
• amb()
• asObserver()
•concatMap
• create
• delaySubscription
• dematerialize
• enumerated
•flatMapFirst
• from
• groupBy
• ifEmpty(switchTo:)
• interval
• materialize
• range
• repeatElement
• retryWhen
• sample
•withLatestFrom
https://github.com/CombineCommunity/rxswift-to-combine-cheatsheet
👋

Operators, Combine Only
Combine에만 있는 Operators
• tryMap
• tryScan
• tryFilter
• tryCompactMap
• tryRemoveDuplicates(by:)
• tryReduce
• tryMax(by:)
• tryMin(by:)
• tryContains(where:)
• tryAllSatisfy
• tryDrop(while:)
• tryPrefix(while:)
• tryFirst(where:)
• tryLast(where:)
• tryCatch
👀

Map vs. tryMap
func map<T>(_ transform: (Output) -> T)
-> Just<T>
func tryMap<T>(_ transform: (Output) throws -> T)
-> Result<T, Error>.Publisher

Combine Operators
• Merge, Merge3,
Merge4, Merge5,
Merge6, Merge7,
Merge8, MergeMany
• merge
• combineLatest• CombineLatest,
CombineLatest3,
CombineLatest4
• zip• Zip, Zip3, Zip4

• ReplaySubject• ❌
• BehaviorSubject• CurrentValueSubject
Subjects
• PassthroughSubject • PublishSubject

Subjects
• PassthroughSubject • PublishSubject
class PassthroughSubject {
public init()
class PublishSubject {
public override init()
⋯
⋯

Subjects
class CurrentValueSubject {
public init(_ value: Output)
class BehaviorSubject {
public init(value: Element)
⋯
⋯

🧟
Cancellable vs. Disposable
🧟

🧟
🧟🗑 • Disposable
• DisposeBag

🧟
🧟🗑 • Disposable
• DisposeBag
• Cancellable
• AnyCancellable

NO DISPOSE BAG!
🗑 🙅

var disposeBag = DisposeBag()
Observable.just(1)
.subscribe(onNext: { number in
print(number)
})
.disposed(by: disposeBag)
var cancellables = Set<AnyCancellable>()
Just(1)
.sink { number in
print(number)
}
.store(in: &cancellables)

Thread Handling
http://reactivex.io/documentation/operators/subscribeon.html

Thread Handling
http://reactivex.io/documentation/operators/subscribeon.html
Just(1)
.subscribe(on: DispatchQueue.main)
.map { _ in
implements()
}
.sink { … }

Combine vs. RxSwift
Publishers
/Subscribers
Observable
/Observer
Subject
Operator
Subject
Operator
subscribe(on:) subscribeOn(_:)

WWDC 2019
•Introducing Combine
•Combine in Practice
•Modern Swift API Design
Reference

https://github.com/ﬁmuxd/BringMyOwnBeer-
PunkAPI by Brewdog
List / Search / Random
https://github.com/ﬁmuxd/BringMyOwnBeer-Combine
BringMyOwnBeer🍺

import RxSwift
import Combine
func getBeers(page: Int?) -> Observable<Result<[Beer], PunkNetworkError>> {
return session.rx.data(request: URLRequest(url: url))
.map { data in
do {
let beers = try JSONDecoder().decode([Beer].self, from: data)
return .success(beers)
} catch {
return .failure(.error("JSON parsing 에러”))
}
}
}
func getBeers(page: Int?) -> AnyPublisher<[Beer], PunkNetworkError> {
return session.dataTaskPublisher(for: URLRequest(url: url))
.flatMap { data in
return Just(data.data)
.decode(type: [Beer].self, decoder: JSONDecoder())
.mapError { _ in
.error("JSON parsing 에러”)
}
}
.eraseToAnyPublisher()
}

import RxSwift
import Combine
.map { data in
do {
} catch {
}
}
}
.flatMap { data in
.mapError { _ in
}
}
}
import RxSwift
import Combine

import RxSwift
import Combine
.map { data in
do {
} catch {
}
}
}
.flatMap { data in
.mapError { _ in
}
}
}
Observable<Result<[Beer], PunkNetworkError>>
AnyPublisher<[Beer], PunkNetworkError>

import RxSwift
import Combine
.map { data in
do {
} catch {
}
}
}
.flatMap { data in
.mapError { _ in
}
}
}
session.rx.data
session.dataTaskPublisher

import RxSwift
import Combine
.map { data in
do {
} catch {
}
}
}
.flatMap { data in
.mapError { _ in
}
}
}
.decode(type:decoder:)
do {
try JSONDecoder().decode(_:from:)
} catch { }

•리스트 형태
•GET beerList API 이용
•한 번에 25개의 맥주 정보
•최대 325개의 맥주 정보
Beer List

import RxSwift
import RxCocoa
Beer List with RxSwift

import RxSwift
import RxCocoa
ViewModel
Bindable
View

import RxSwift
import RxCocoa
View
UIViewController

import RxSwift
import RxCocoa
View
UIViewController
UITableView

import RxSwift
import RxCocoa
View
UIViewController
UITableView
UITableViewDelegate

import RxSwift
import RxCocoa
View
func items<S, O>(_ source: O)
-> (@escaping (UITableView, Int, S.Iterator.Element)
-> UITableViewCell)
-> Disposable
where S : Sequence, S == O.E, O : ObservableType
public var willDisplayCell: ControlEvent<WillDisplayCellEvent> { }
UIViewController
UITableView
UITableViewDelegate

import RxSwift
import RxCocoa
View
ViewModel
Bindable
UIViewController
UITableView
UITableViewDelegate

UIViewController
UITableView
UITableViewDelegate
import RxSwift
import RxCocoa
View
ViewModel
Bindable
var viewWillAppear: PublishSubject<Void> { get }
var willDisplayCell: PublishRelay<IndexPath> { get }

UIViewController
UITableView
UITableViewDelegate
import RxSwift
import RxCocoa
View
ViewModel
Bindable
var cellData: Driver<[BeerListCell.Data]> { get }
var errorMessage: Signal<String> { get }

class BeerListViewController: UIViewController {
let tableView = UITableView()
func bind(_ viewModel: BeerListViewBindable) {
self.disposeBag = DisposeBag()
self.rx.viewWillAppear
.map { _ in Void() }
.bind(to: viewModel.viewWillAppear)
viewModel.cellData
.drive(tableView.rx.items) { tv, row, data in
let index = IndexPath(row: row, section: 0)
let cell = tv.dequeueReusableCell(
withIdentifier: String(describing: BeerListCell.self),
for: index
) as! BeerListCell
cell.setData(data: data)
return cell
}
}
func attribute() { }
func layout() { }

viewModel.cellData
for: index
) as! BeerListCell
return cell
}
}
func layout() { }

viewModel.cellData
for: index
) as! BeerListCell
return cell
}
}
func layout() { }
viewModel.cellData
.drive(tableView.rx.items) { }

protocol BeerListViewBindable {
//View -> ViewModel
var viewWillAppear: PublishSubject<Void> { get }
var willDisplayCell: PublishRelay<IndexPath> { get }
//ViewModel -> View
var cellData: Driver<[BeerListCell.Data]> { get }
var errorMessage: Signal<String> { get }
}

struct BeerListViewModel: BeerListViewBindable {
let disposeBag = DisposeBag()
let viewWillAppear = PublishSubject<Void>()
let cellData: Driver<[BeerListCell.Data]>
let willDisplayCell = PublishRelay<IndexPath>()
let errorMessage: Signal<String>
private var cells = BehaviorRelay<[Beer]>(value: [])
init(model: BeerListModel = BeerListModel()) {

let beerListResult = viewWillAppear
.flatMapLatest(model.getBeerList)
.asObservable()
.share()
let beerListValue = beerListResult
.map { result -> [Beer]? in
guard case .success(let value) = result else {
return nil
}
return value
}
.filterNil()
let beerListError = beerListResult
.map { result -> String? in
guard case .failure(let error) = result else {
return nil
}
return error.message
}
.filterNil()

Observable
.merge(
beerListValue,
fetchedList
)
.scan([]){ prev, newList in
return newList.isEmpty ? [] : prev + newList
}
.bind(to: cells)
self.cellData = cells
.map(model.parseData)
.asDriver(onErrorDriveWith: .empty())
self.errorMessage = Observable
.merge(
beerListError,
fetchedError
)
.asSignal(onErrorJustReturn: .defaultError.message ?? “")
}

import Combine
import SwiftUI
Beer List with Combine

UI Binding
Combine
SwiftUI
RxSwift
RxCocoa

View 는,
https://developer.apple.com/videos/play/wwdc2019/226
Views are a function of state,
not of a sequence of events.

Property Wrapper
@State @ObservableObject

Property Wrapper
View-local External

Property Wrapper
View-local External
prev) BindableObject

Property Wrapper
View-local
Value type
External
Reference type

Property Wrapper
View-local
Value type
Framework Managed
External
Reference type
Developer Managed

🧑💻
SwiftUI
Action
User Interaction
Data Flow through SwiftUI

🧑💻
SwiftUI
Action
@StateMutation
User Interaction

🧑💻
SwiftUI
Action View
@State UpdatesMutation
User Interaction

🧑💻
SwiftUI
Action View
@State
Render
UpdatesMutation
User Interaction

🧑💻
SwiftUI
Action
@State
Render
UpdatesMutation
User Interaction
🧨 🍺
@Publisher
View

import SwiftUI
struct BeerList: View {
@ObservedObject var viewModel: BeerListViewModel
init(viewModel: BeerListViewModel) {
self.viewModel = viewModel
}
var body: some View {
NavigationView {
List(viewModel.beers, id: .id) { beer in
BeerRow(beer: beer).onAppear {
self.viewModel.appearedID.send(beer.id)
}
}
.navigationBarTitle(Text("맥주리스트"))
}
.alert(isPresented: $viewModel.showingAlert) {
Alert(title: Text(viewModel.errorMessage))
}
}
}

}
NavigationView {
}
}
}
}
}
}

class BeerListViewModel: ObservableObject {
@Published var beers: [Beer] = []
@Published var showingAlert: Bool = false
@Published var errorMessage: String = ""
let appearedID = PassthroughSubject<Int?, PunkNetworkError>()
private var cancellables = Set<AnyCancellable>()

//ViewModel -> View
@Published var showingAlert: Bool = false
@Published var errorMessage: String = ""
//View -> ViewModel
let appearedID = PassthroughSubject<Int?, PunkNetworkError>()
private var cancellables = Set<AnyCancellable>()

let loadBeerList = appearedID
.map { model.getPageToPatch(beers: self.beers, id: $0) }
.filter { $0 != nil }

let loadBeerList = appearedID
.map { model.getPageToPatch(beers: self.beers, id: $0) }
.filter { $0 != nil }
.eraseToAnyPublisher() .asObservable()

loadBeerList
.prepend(nil)
.flatMap(model.getBeerList)
.receive(on: DispatchQueue.main)
.sink(receiveCompletion: {
guard case .failure(let error) = $0 else { return }
self.beers = []
self.showingAlert = true
self.errorMessage = error.message ?? "에러 발생🚨”
}, receiveValue: { beers in
self.beers += beers
})
}
}

loadBeerList
.prepend(nil)
self.beers = []
self.beers += beers
})
}
}
.sink(
receiveCompletion:
receiveValue:
)
.subscribe(
onNext:
onError:
onCompleted:
onDisposed:
)

loadBeerList
.prepend(nil)
self.beers = []
self.beers += beers
})
}
}

import SwiftUI
}
NavigationView {
}
}
}
}
}
}
struct List: View {
public init(
_ data: Data,
id: KeyPath<Data.Element, ID>,
⋯

Combine/SwiftUI RxSwift/RxCocoa
Summary

App Size
0MB
1MB
2MB
3MB
4MB
Combine RxSwift
Summary

Summary
https://medium.com/ﬂawless-app-stories/will-combine-kill-rxswift-64780a150d89

Summary
The memory models of RxSwift and Combine are very different.
Combine is really made for performance.
https://engineering.q42.nl/swift-combine-framework/

Summary
👨💻 ❤ Combine
👩💻 ❓ RxSwift

Summary
👩💻 ❤ Combine

Summary
👩💻 ❤ Combine
🎁 SwiftUI
✨
✨ ✨
✨ ✨

Summary
👨💻
❤
Combine👩💻
❤
Combine
🎁 SwiftUI

🎁 SwiftUI
👨💻
❤
Combine👩💻
❤
Combine
Summary
iOS 13.0+
⚡⚡⚡
⚡⚡⚡
⚡⚡⚡

완벽함이란 더 이상 더할 것이 없는 상태가 아니라,
더 이상 뺄 것이 없는 상태를 말한다.
Antoine de Saint-Exupéry

RxSwift to Combine

More Related Content

What's hot

Similar to RxSwift to Combine

Recently uploaded

RxSwift to Combine