class SimpleViewController: UIViewController {
    // IBOutlet などが接続された View。
    //
    // 上級者向け注釈1: View の持ち方について（記事末を参照）。
    // 上級者向け注釈2: weak じゃない理由について（記事末を参照）。
    private let rootView: SimpleRootView
    private var viewModel: SimpleViewModel?

    // 上級者向け注釈3: フレームワーク名をつけることについて（記事末を参照）。
    private let disposeBag = RxSwift.DisposeBag()

    // ...

    override func viewDidLoad() {
        super.viewDidLoad()

        // ViewModel への UI イベントを流す Observable は、ViewModel の初期化時に
        // IBOutlet などから作成して渡す。
        let viewModel = SimpleViewModel(

            // inputOutlet は IBOutlet で接続された UITextField のインスタンス。
            // RxCocoa を使うと、UITextField の rx.text から、入力された文字列を
            // Observable に類似した形式（ControlProperty型）で取得できる。
            // ここから、ViewModel が要求する Driver 型へ変換する（Driver の説明は後述）。
            input: self.rootView.inputOutlet.rx.text.orEmpty.asDriver()
        )

        // ViewModel からの指示は ViewModel のプロパティにある Driver 経由で
        // 購読して反映させる。
        // ここでは ViewModel が指示した文字列を、outputOutlet の指す
        // UILabel の表示文字列へと反映させている。
        viewModel.outputText
            .drive(self.rootView.outputOutlet.rx.text)
            .disposed(by: self.disposeBag)

        // ViewModel が ARC で回収されないように保持しておく。
        //
        // 上級者向け注釈4: ViewModel を保持していることについて（記事末を参照）。
        self.viewModel = viewModel
    }

    // ...
}

class SimpleViewModel {
    // View への指示を ViewModel のプロパティとして公開する。
    // ViewModel のプロパティの型は Driver か Signal のどちらかにする
    // （Driver と Signal についての説明は後述）。
    let outputText: RxCocoa.Driver<String>


    // View からの UI イベントは init 関数の input 引数から受け取る。
    init(input inputText: RxCocoa.Driver<String>) {
        self.outputText = inputText
            .map { text in text.uppercased() }
            .asDriver()
    }
}

class BadgesSelectorViewModel {
    typealias Dependency = (
        // 依存: すべてのバッジの一覧を取得するためのリポジトリ。
        repository: AnyEntityRepository<Void, [Badge], Never>,
        // 依存: 別の画面へ遷移するためのクラス。このクラスのメソッドを
        // 叩くと新しい画面へ遷移できる。この種のクラスは RxExample で
        // Wireframe と命名されている。
        wireframe: BadgeSelectorWireframe
    )

    typealias Input = (
        // View からの入力: 完了ボタンのタップイベント、
        doneTap: RxCocoa.Signal<Void>,

        // View からの入力: 選択されているバッジへのタップイベント。
        selectedTap: RxCocoa.Signal<Badge>,

        // View からの入力: まだ選択されていないバッジへのタップイベント。
        selectableTap: RxCocoa.Signal<Badge>
    )

    // View への出力: Done ボタンの有効/無効フラグ の Driver。
    let canComplete: RxCocoa.Driver<Bool>

    // View への出力: 上部に表示するバッジの一覧の Driver。
    let selectedBadges: RxCocoa.Driver<[Badge]>

    // View への出力: 下部に表示するバッジの一覧の Driver。
    let selectableBadges: RxCocoa.Driver<[Badge]>

    // View への出力: 選択解除されたバッジを通知する Signal。
    let badgeDidDeselect: RxCocoa.Signal<Badge>

    // View への出力: 選択されたバッジを通知する Signal。
    let badgeDidSelect: RxCocoa.Signal<Badge>

    var currentSelectedBadges: [Badge] {
        return self.selectedBadgesRelay.value
    }

    private let badgeDidSelectRelay: RxCocoa.PublishRelay<Badge>
    private let badgeDidDeselectRelay: RxCocoa.PublishRelay<Badge>
    private let selectedBadgesRelay: RxCocoa.BehaviorRelay<[Badge]>
    private let dependency: Dependency
    private let disposeBag = RxSwift.DisposeBag()


    init(input: Input, dependency: Dependency) {
        self.dependency = dependency

        // バッジが選択されたことを UIView へ通知するための PublishRelay。
        // PublishRelay は任意のイベントが流せる Signal のようなもの。
        // 最終的に Signal へ変換して View へ公開する。
        //
        // 上級者向け注釈5: インスタンス変数代入と変数定義を分けていることについて（記事末を参照）。
        let badgeDidSelectRelay = RxCocoa.PublishRelay<Badge>()
        self.badgeDidSelectRelay = badgeDidSelectRelay
        self.badgeDidSelect = badgeDidSelectRelay.asSignal()

        // バッジの選択が解除されたことを UIView へ通知するための PublishRelay。
        let badgeDidDeselectRelay = RxCocoa.PublishRelay<Badge>()
        self.badgeDidDeselectRelay = badgeDidDeselectRelay
        self.badgeDidDeselect = badgeDidDeselectRelay.asSignal()

        // 選択済みのバッジの出力。選択されたバッジは保持しておかないといけないので、
        // BehaviorRelay を使って保持している。BehaviorRelay は任意のイベントが
        // 流せる Driver のようなもの。最終的に Driver へ変換して View へ公開する。
        let selectedBadgesRelay = RxCocoa.BehaviorRelay<[Badge]>(value: [])
        self.selectedBadgesRelay = selectedBadgesRelay
        let selectedBadges = selectedBadgesRelay.asDriver()
        self.selectedBadges = selectedBadges

        // すべてのバッジを保持しておくための BehaviorRelay。
        let allBadgesRelay = RxCocoa.BehaviorRelay<[Badge]>(value: [])
        let allBadges = allBadgesRelay.asDriver()

        // すべてのバッジをサーバーから取得（今回は簡単にするためにダミーのものがくる）。
        dependency.repository
            .get(count: 100)
            .subscribe(
                onSuccess: { result in
                    switch result {
                    case let .success(badges):
                        // 取得が成功したらすべてのバッジを更新する。
                        allBadgesRelay.accept(badges)
                    case .failure:
                        break
                    }
                },
                onError: nil
            )
            .disposed(by: self.disposeBag)

        // 選択可能なバッジの出力。
        self.selectableBadges = RxCocoa.Driver
            .combineLatest(
                allBadges,
                selectedBadges,
                resultSelector: { ($0, $1) }
            )
            .map { tuple -> [Badge] in
                let (allBadges, selectedBadges) = tuple
                // すべてのバッジから、既に選択されたものを除く。
                return BadgesSelectorViewModel.dropSelected(
                    from: allBadges,
                    without: Set(selectedBadges)
                )
            }

        // バッジが一つも選択されていなければ UINavigationBar 上の
        // Done ボタンを無効にする。
        self.canComplete = selectedBadges
            .map { selection in !selection.isEmpty }
            .asDriver()

        // Done ボタンタップ時に画面を遷移させる。
        input.doneTap
            .emit(onNext: { [weak self] _ in
                guard let `self` = self else { return }

                self.dependency.wireframe.goToResultScreen(
                    with: selectedBadgesRelay.value
                )
            })
            .disposed(by: self.disposeBag)

        // 上部バッジタップで選択を解除する。
        input.selectedTap
            .emit(onNext: { [weak self] badge in
                guard let `self` = self else { return }

                self.deselect(badge: badge)
            })
            .disposed(by: self.disposeBag)

        // 下部バッジタップで選択する。
        input.selectableTap
            .emit(onNext: { [weak self] badge in
                guard let `self` = self else { return }

                self.select(badge: badge)
            })
            .disposed(by: self.disposeBag)
    }


    // 与えられたバッジを選択状態にする。
    private func select(badge: Badge) {
        let currentSelection = self.selectedBadgesRelay.value
        guard !currentSelection.contains(badge) else { return }

        var newSelection = currentSelection
        newSelection.append(badge)

        self.selectedBadgesRelay.accept(newSelection)
        self.badgeDidSelectRelay.accept(badge)
    }


    // 与えられたバッジを非選択状態にする。
    private func deselect(badge: Badge) {
        let currentSelection = self.selectedBadgesRelay.value
        var newSelection = currentSelection

        guard let index = newSelection.index(of: badge) else { return }

        newSelection.remove(at: index)

        self.selectedBadgesRelay.accept(newSelection)
        self.badgeDidDeselectRelay.accept(badge)
    }


    private static func dropSelected(from allBadges: [Badge], without selectedBadges: Set<Badge>) -> [Badge] {
        return allBadges
            .filter { !selectedBadges.contains($0) }
    }
}

// Done ボタンに対応する ViewModel。
class BadgeSelectorCompletionViewModel {
    typealias Dependency = (
        // 依存: 選択された badge 数の変化がわかる BehaviorRelay。
        selectedBadgesRelay: RxCocoa.BehaviorRelay<[Badge]>,
        wireframe: BadgeSelectorWireframe
    )

    // View への出力: Done ボタンの有効/無効フラグ の Driver。
    let canComplete: RxCocoa.Driver<Bool>


    private let dependency: Dependency
    private let disposeBag = DisposeBag()


    init(
        // View からの入力: Done ボタンのタップイベントの Signal。
        input doneTap: RxCocoa.Signal<Void>,
        dependency: Dependency
    ) {
        self.dependency = dependency

        // バッジが一つも選択されていなければ UINavigationBar 上の
        // Done ボタンを無効にする。
        self.canComplete = dependency.selectedBadgesRelay
            .map { selection in !selection.isEmpty }
            .asDriver(onErrorDriveWith: .empty())

        // Done ボタンタップ時に画面を遷移させる。
        doneTap
            .emit(onNext: { [weak self] _ in
                guard let `self` = self else { return }

                self.dependency.wireframe.goToResultScreen(
                    with: self.dependency.selectedBadgesRelay.value
                )
            })
            .disposed(by: self.disposeBag)
    }
}

// 選択されたバッジの表示 UI に対応する ViewModel。
class SelectedBadgesViewModel {
    // View への出力: 上部に表示するバッジの一覧の Driver。
    let selectedBadges: RxCocoa.Driver<[Badge]>

    // View への出力: 選択解除されたバッジを通知する Signal。
    let badgeDidDeselect: RxCocoa.Signal<Badge>

    private let selectedBadgesRelay: RxCocoa.BehaviorRelay<[Badge]>
    private let badgeDidDeselectRelay: RxCocoa.PublishRelay<Badge>

    private let disposeBag = RxSwift.DisposeBag()


    init(
        // View からの入力: 上部バッジのタップイベントの Signal。
        input selectedTap: RxCocoa.Signal<Badge>,

        // 依存: 選択された badge の一覧を保持した BehaviorRelay。
        dependency selectedBadgesRelay: RxCocoa.BehaviorRelay<[Badge]>
    ) {
        // 選択済みのバッジの出力を。
        self.selectedBadgesRelay = selectedBadgesRelay
        self.selectedBadges = selectedBadgesRelay.asDriver()

        // バッジの選択が解除されたことを UIView へ通知するための PublishRelay。
        let badgeDidDeselectRelay = RxCocoa.PublishRelay<Badge>()
        self.badgeDidDeselectRelay = badgeDidDeselectRelay
        self.badgeDidDeselect = badgeDidDeselectRelay.asSignal()

        // 上部バッジタップで選択を解除する。
        selectedTap
            .emit(onNext: { [weak self] badge in
                guard let `self` = self,
                      let index = self.selectedBadgesRelay.value.index(of: badge) else { return }

                var newSelectedBadges = self.selectedBadgesRelay.value
                newSelectedBadges.remove(at: index)
                self.selectedBadgesRelay.accept(newSelectedBadges)

                self.badgeDidDeselectRelay.accept(badge)
            })
            .disposed(by: self.disposeBag)
    }
}

// まだ選択されていないバッジの表示 UI に対応する ViewModel。
class SelectableBadgesViewModel {
    typealias Dependency = (
        // 依存: 選択された badge の一覧を保持した BehaviorRelay。
        selectedBadgesRelay: RxCocoa.BehaviorRelay<[Badge]>,

        // 依存: 選択されていない badge の一覧を保持した BehaviorRelay。
        selectableBadgesRelay: RxCocoa.BehaviorRelay<[Badge]>
    )

    // View への出力: 下部に表示するバッジの一覧の Driver。
    let selectableBadges: RxCocoa.Driver<[Badge]>

    // View への出力: 選択されたバッジを通知する Signal（上部画面のスクロールに使われる）。
    let badgeDidSelect: RxCocoa.Signal<Badge>

    private let badgeDidSelectRelay: RxCocoa.PublishRelay<Badge>
    private let dependency: Dependency
    private let disposeBag = RxSwift.DisposeBag()


    init(
        // View からの入力: 下部バッジのタップイベントの Signal。
        input selectableTap: RxCocoa.Signal<Badge>,
        dependency: Dependency
    ) {
        self.dependency = dependency

        // バッジが選択されたことを UIView へ通知するための PublishRelay。
        let badgeDidSelectRelay = RxCocoa.PublishRelay<Badge>()
        self.badgeDidSelectRelay = badgeDidSelectRelay
        self.badgeDidSelect = badgeDidSelectRelay.asSignal()

        // 選択可能なバッジの出力。
        self.selectableBadges = dependency.selectableBadgesRelay.asDriver()

        // 下部バッジタップで選択する。
        selectableTap
            .emit(onNext: { [weak self] badge in
                guard let `self` = self else { return }

                var newSelectedBadges = self.dependency.selectedBadgesRelay.value
                newSelectedBadges.append(badge)
                self.dependency.selectedBadgesRelay.accept(newSelectedBadges)

                self.badgeDidSelectRelay.accept(badge)
            })
            .disposed(by: self.disposeBag)
    }
}

class BadgesSelectorViewModel {
    typealias Dependency = (
        repository: AnyEntityRepository<Void, [Badge], Never>,
        wireframe: BadgeSelectorWireframe
    )
    typealias Input = (
        // View からの入力: Done ボタンのタップイベントの Signal。
        doneTap: RxCocoa.Signal<Void>,

        // View からの入力: 上部バッジのタップイベントの Signal。
        selectedTap: RxCocoa.Signal<Badge>,

        // View からの入力: 下部バッジのタップイベントの Signal。
        selectableTap: RxCocoa.Signal<Badge>
    )

    // View への出力: 子の ViewModel のプロパティを介して各コンポーネントへの出力を公開する。
    let selectedViewModel: SelectedBadgesViewModel
    let selectableViewModel: SelectableBadgesViewModel
    let completionViewModel: BadgeSelectorCompletionViewModel

    var currentSelectedBadges: [Badge] {
        return self.selectedBadgesRelay.value
    }

    private let allBadgesRelay: RxCocoa.BehaviorRelay<[Badge]>
    private let selectedBadgesRelay: RxCocoa.BehaviorRelay<[Badge]>
    private let selectableBadgesRelay: RxCocoa.BehaviorRelay<[Badge]>
    private let disposeBag = RxSwift.DisposeBag()


    init(input: Input, dependency: Dependency) {
        let allBadgesRelay = RxCocoa.BehaviorRelay<[Badge]>(value: [])
        self.allBadgesRelay = allBadgesRelay
        let selectedBadgesRelay = RxCocoa.BehaviorRelay<[Badge]>(value: [])
        self.selectedBadgesRelay = selectedBadgesRelay
        let selectableBadgesRelay = RxCocoa.BehaviorRelay<[Badge]>(value: [])
        self.selectableBadgesRelay = selectableBadgesRelay

        // 子の ViewModel を内部的に作成する。
        self.selectedViewModel = SelectedBadgesViewModel(
            input: input.selectedTap,
            dependency: selectedBadgesRelay
        )
        self.selectableViewModel = SelectableBadgesViewModel(
            input: input.selectableTap,
            dependency: (
                selectedBadgesRelay: selectedBadgesRelay,
                selectableBadgesRelay: selectableBadgesRelay
            )
        )
        self.completionViewModel = BadgeSelectorCompletionViewModel(
            input: input.doneTap,
            dependency: (
                selectedBadgesRelay: selectedBadgesRelay,
                wireframe: dependency.wireframe
            )
        )

        // バッジの取得処理は、まだこのまとめ役 ViewModel が管理する必要がある。
        dependency.repository
            .get(count: 100)
            .subscribe(
                onSuccess: { [weak self] result in
                    guard let `self` = self else { return }

                    switch result {
                    case let .success(badges):
                        self.allBadgesRelay.accept(badges)
                    case .failure:
                        break
                    }
                },
                onError: nil
            )
            .disposed(by: self.disposeBag)

        // 選択可能なバッジの出力。
        RxCocoa.Driver
            .combineLatest(
                allBadgesRelay.asDriver(),
                selectedBadgesRelay.asDriver(),
                resultSelector: { ($0, $1) }
            )
            .map { tuple -> [Badge] in
                let (allBadges, selectedBadges) = tuple
                // すべてのバッジから既に選択されているバッジを除く。
                return BadgesSelectorViewModel.dropSelected(
                    from: allBadges,
                    without: Set(selectedBadges)
                )
            }
            .drive(selectableBadgesRelay)
            .disposed(by: self.disposeBag)
    }


    private static func dropSelected(from allBadges: [Badge], without selectedBadges: Set<Badge>) -> [Badge] {
        return allBadges
            .filter { !selectedBadges.contains($0) }
    }
}

// Model 層は Protocol にしておくと ViewModel のテストがやりやすくなる。
// ViewModel のテストでは偽物の Model と差し替えると挙動が確認しやすくなるため。
protocol SelectedBadgesModel {
    // 選択されたバッジの一覧に変化があったら通知する Driver。
    var selectionDidChange: RxCocoa.Driver<[Badge]> { get }

    // 現在選択されているバッジ。
    var currentSelection: [Badge] { get }

    // 新たに選択されたバッジを通知する Driver。
    var badgeDidSelect: RxCocoa.Signal<Badge> { get }

    // 新たに選択解除されたバッジを通知する Driver。
    var badgeDidDeselect: RxCocoa.Signal<Badge> { get }

    // 与えられたバッジを選択する。
    func select(badge: Badge)

    // 与えられたバッジの選択を解除する。
    func deselect(badge: Badge)
}



// 上の Protocol を実装した本体実装。
class DefaultSelectedBadgesModel: SelectedBadgesModel {
    private let selectedBadgesRelay: RxCocoa.BehaviorRelay<[Badge]>
    private let badgeDidSelectRelay: RxCocoa.PublishRelay<Badge>
    private let badgeDidDeselectRelay: RxCocoa.PublishRelay<Badge>

    let badgeDidSelect: RxCocoa.Signal<Badge>
    let badgeDidDeselect: RxCocoa.Signal<Badge>
    let selectionDidChange: RxCocoa.Driver<[Badge]>


    var currentSelection: [Badge] {
        get { return self.selectedBadgesRelay.value }
        set { self.selectedBadgesRelay.accept(newValue) }
    }


    init(selected initialSelection: [Badge]) {
        self.stateMachine = StateMachine(
            startingWith: initialSelection
        )

        let badgeDidSelectRelay = RxCocoa.PublishRelay<Badge>()
        self.badgeDidSelectRelay = badgeDidSelectRelay
        self.badgeDidSelect = badgeDidSelectRelay.asSignal()

        let badgeDidDeselectRelay = RxCocoa.PublishRelay<Badge>()
        self.badgeDidDeselectRelay = badgeDidDeselectRelay
        self.badgeDidDeselect = badgeDidDeselectRelay.asSignal()

        self.selectionDidChange = stateMachine.stateDidChange
    }


    func select(badge: Badge) {
        guard !self.currentSelection.contains(badge) else { return }

        var newSelection = self.currentSelection
        newSelection.append(badge)

        self.currentSelection = newSelection

        self.badgeDidSelectRelay.accept(badge)
    }


    func deselect(badge: Badge) {
        var newSelection = self.currentSelection

        guard let index = newSelection.index(of: badge) else { return }

        newSelection.remove(at: index)

        self.currentSelection = newSelection

        self.badgeDidDeselectRelay.accept(badge)
    }
}

class SelectedBadgesViewModel {
    let selectedBadges: RxCocoa.Driver<[Badge]>
    let badgeDidSelect: RxCocoa.Signal<Badge>
    let badgeDidDeselect: RxCocoa.Signal<Badge>

    private let selectedModel: SelectedBadgesModel
    private let disposeBag = RxSwift.DisposeBag()


    init(
        input selectedTap: RxCocoa.Signal<Badge>,
        // init 関数の引数から SelectedBadgesModel を注入する。
        dependency selectedModel: SelectedBadgesModel
    ) {
        self.selectedModel = selectedModel
        self.selectedBadges = selectedModel.selectionDidChange
        self.badgeDidSelect = selectedModel.badgeDidSelect
        self.badgeDidDeselect = selectedModel.badgeDidDeselect

        // 上部バッジのタップでバッジの選択を解除する。
        selectedTap
            .emit(onNext: { [weak self] badge in
                guard let `self` = self else { return }

                // 選択解除に関する処理が Model 層へと移動したため、見通しがよくなった。
                self.selectedModel.deselect(badge: badge)
            })
            .disposed(by: self.disposeBag)
    }
}

// ViewModel のテストを容易にするために Protocol にする。
protocol AllBadgesModel: class {
    // バッジの取得状態が変化したら通知する Driver。
    var stateDidChange: RxCocoa.Driver<AllBadgesModelState> { get }

    // 現在のバッジの取得状態。
    var currentState: AllBadgesModelState { get }
}



// バッジの取得状態の型。
enum AllBadgesModelState {
    // まだ取得されていない状態。
    case notFetchedYet

    // 取得中の状態。
    case fetching

    // 取得が完了した状態。
    case fetched(result: Result<[Badge], FailureReason>)


    var badges: [Badge] {
        switch self {
        case let .fetched(result: .success(badges)):
            return badges
        case .notFetchedYet, .fetching, .fetched(result: .failure):
            return []
        }
    }


    var isFetching: Bool {
        switch self {
        case .fetching:
            return true
        case .notFetchedYet, .fetched:
            return false
        }
    }


    enum FailureReason {
        case unspecified(debugInfo: String)
    }
}



class DefaultAllBadgesModel: AllBadgesModel {
    let stateDidChange: RxCocoa.Driver<AllBadgesModelState>


    var currentState: AllBadgesModelState {
        get { return self.stateRelay.value }
        set { self.stateRelay.accept(newValue) }
    }


    private let stateRelay: RxCocoa.BehaviorRelay<AllBadgesModelState>
    private let repository: BadgesRepository
    private let disposeBag = RxSwift.DisposeBag()


    init(gettingBadgesVia repository: BadgesRepository) {
        self.repository = repository
        self.stateRelay = RxCocoa.BehaviorRelay<AllBadgesModelState>(value: .notFetchedYet)
        self.stateDidChange = stateRelay.asDriver()

        self.fetch()
    }


    // バッジの一覧を更新する。もし、バッジの一覧の更新の仕様追加があっても、
    // このメソッドを public にするだけでよい。
    private func fetch() {
        // すでに更新中だったら fetch しない。
        guard !self.currentState.isFetching else { return }
        self.currentState = .fetching

        // リポジトリからすべてのバッジを取得する。
        self.repository
            .get(count: 100)
            .subscribe(
                onSuccess: { [weak self] result in
                    guard let `self` = self else { return }

                    switch result {
                    // もし取得に成功したら、バッジを BehaviorRelay に保持する。
                    case let .success(badges):
                        self.currentState = .fetched(result: .success(badges))

                    // もし取得に失敗したら、失敗理由を保持しておく。
                    case let .failure(reason):
                        self.currentState = .fetched(result: .failure(.unspecified(debugInfo: "\(reason)")))
                    }
                },
                onError: { [weak self] error in
                    guard let `self` = self else { return }

                    // もし取得に失敗したら、失敗理由を保持しておく。
                    self.currentState = .fetched(result: .failure(.unspecified(debugInfo: "\(error)")))
                }
            )
            .disposed(by: self.disposeBag)
    }
}

// ViewModel のテストを容易にするために Protocol にする。
protocol SelectableBadgesModel {
    // 選択可能なバッジの一覧が変化したら通知する Driver。
    var selectableBadgesDidChange: RxCocoa.Driver<[Badge]> { get }

    // 現在選択可能なバッジの一覧。
    var currentSelectableBadges: [Badge] { get }
}



class DefaultSelectableBadgesModel: SelectableBadgesModel {
    typealias Dependency = (
        allModel: AllBadgesModel,
        selectedModel: SelectedBadgesModel
    )
    private let disposeBag = RxSwift.DisposeBag()
    private let dependency: Dependency
    private let selectableBadgesRelay: RxCocoa.BehaviorRelay<[Badge]>


    let selectableBadgesDidChange: RxCocoa.Driver<[Badge]>


    var currentSelectableBadges: [Badge] {
        return selectableBadgesRelay.value
    }


    init(dependency: Dependency) {
        self.dependency = dependency

        // NOTE: 選択できるバッジの一覧を同期的に取得できるようにするために
        // BehaviorRelay を使う。
        let selectableBadgesRelay = RxCocoa.BehaviorRelay(
            value: DefaultSelectableBadgesModel.dropSelected(
                from: dependency.allModel.currentState.value ?? [],
                without: Set(dependency.selectedModel.currentSelection)
            )
        )
        self.selectableBadgesRelay = selectableBadgesRelay
        self.selectableBadgesDidChange = selectableBadgesRelay.asDriver()

        RxCocoa.Driver
            .combineLatest(
                dependency.allModel.stateDidChange,
                dependency.selectedModel.selectionDidChange,
                resultSelector: { ($0, $1) }
            )
            .map { tuple -> [Badge] in
                let (allBadgesModelState, selectedBadges) = tuple
                return DefaultSelectableBadgesModel.dropSelected(
                    from: allBadgesModelState.value ?? [],
                    without: Set(selectedBadges)
                )
            }
            .drive(self.selectableBadgesRelay)
            .disposed(by: self.disposeBag)
    }


    private static func dropSelected(from allBadges: [Badge], without selectedBadges: Set<Badge>) -> [Badge] {
        return allBadges
            .filter { !selectedBadges.contains($0) }
    }
}

class BadgesSelectorViewModel {
    typealias Dependency = (
        selectedModel: SelectedBadgesModel,
        selectableModel: SelectableBadgesModel,
        wireframe: BadgeSelectorWireframe
    )
    typealias Input = (
        // View からの入力: Done ボタンのタップイベントの Signal。
        doneTap: RxCocoa.Signal<Void>,

        // View からの入力: 上部バッジのタップイベントの Signal。
        selectedTap: RxCocoa.Signal<Badge>,

        // View からの入力: 下部バッジのタップイベントの Signal。
        selectableTap: RxCocoa.Signal<Badge>
    )

    // View への出力: 子の ViewModel のプロパティを介して各コンポーネントへの出力を公開する。
    let selectedViewModel: SelectedBadgesViewModel
    let selectableViewModel: SelectableBadgesViewModel
    let completionViewModel: BadgeSelectorCompletionViewModel

    private let disposeBag = RxSwift.DisposeBag()


    init(input: Input, dependency: Dependency) {
        let selectedModel = dependency.selectedModel

        self.selectedViewModel = SelectedBadgesViewModel(
            input: input.selectedTap,
            dependency: selectedModel
        )

        self.selectableViewModel = SelectableBadgesViewModel(
            input: input.selectableTap,
            dependency: (
                selectedModel: selectedModel,
                selectableModel: dependency.selectableModel
            )
        )

        self.completionViewModel = BadgeSelectorCompletionViewModel(
            input: input.doneTap,
            dependency: (
                selectedModel: selectedModel,
                wireframe: dependency.wireframe
            )
        )
    }
}