Reactor Kit

MasterViewController.swift

class MasterViewController: UICollectionViewController, UICollectionViewDelegateFlowLayout, View {
    func bind(reactor: MasterViewReactor) {
        self.refreshControl.rx
            .controlEvent(.valueChanged)
            .filter { _ in self.refreshControl.isRefreshing }
            .subscribe(self.refresher)
            .disposed(by: self.disposeBag)
        
        self.refresher
            .map { Reactor.Action.refreshList }
            .subscribe(reactor.action)
            .disposed(by: self.disposeBag)
        
        self.autorefreshIsRunning
            .asObservable()
            .flatMapLatest { isRunning in isRunning ? Observable<Int>.interval(60, scheduler: MainScheduler.instance) : .empty() }
            .asObservable()
            .map{ _ in return }
            .subscribe(self.refresher)
            .disposed(by: self.disposeBag)
        
        reactor.state
            .observeOn(MainScheduler.instance)
            .subscribe(onNext: self.handleState)
            .disposed(by: self.disposeBag)
    }
}

MasterViewReactor.swift

final class MasterViewReactor: Reactor {
    let service: ServiceType
    
    init(service: ServiceType = Service()) {
        self.service = service
    }
    
    enum Action {
        case refreshList
    }
    
    enum Mutation {
        case updateStatus(Result<(CurrentPrice, [PriceModel]), Error>)
    }
    
    enum State {
        case loading
        case showList(CurrentPriceUIModel, [PastPriceUIModel])
        case failure
    }
    
    let initialState: State = .loading
    
    func mutate(action: Action) -> Observable<Mutation> {
        switch action {
        case .refreshList:
            return Observable.zip(self.service.currentprice(), self.service.historicalprices(for: .EUR)) { currentprice, historicalprices in
                if case let .failure(error) = currentprice {
                    return .updateStatus(.failure(error))
                }
                if case let .failure(error) = historicalprices {
                    return .updateStatus(.failure(error))
                }
                
                return try! .updateStatus(.success((currentprice.get(), historicalprices.get())))
            }
        }
    }
    
    func reduce(state: MasterViewReactor.State, mutation: MasterViewReactor.Mutation) -> MasterViewReactor.State {
        switch mutation {
        case .updateStatus(let result): return self.handleReloadResult(result)
        }
    }
    
    private func handleReloadResult(_ result: Result<(CurrentPrice, [PriceModel]), Error>) -> State {
        switch result {
        case .failure: return .failure
        case let .success((currentprice, historicalprices)): return .showList(currentprice, historicalprices)
        }
    }
}