public protocol IORouter {
  /* 
    Defines type of application model.
  */
  associatedtype Frame
  
  /*
    Defines initial values of application model.
  */
  static var seed: Frame { get }

  /* 
    Defines drivers that handle frames, produce events. Requires two default drivers: 

      1. let application: UIApplicationDelegateProviding - can serve as UIApplicationDelegate
      2. let screen: ScreenDrivable - can provide a root UIViewController

    A default UIApplicationDelegateProviding driver, RxUIApplicationDelegate, is included with Cycle.
  */
  associatedtype Drivers: UIApplicationDelegateProviding, ScreenDrivable

  /*
    Instantiates drivers with initial model. Necessary to for drivers that require initial values.
  */
  func driversFrom(seed: Frame) -> Drivers

  /*
    Returns a stream of Model created by rendering the incoming stream of frames to drivers and then capturing and transforming their events into the Model type. See example for intended implementation.
  */
  func effectsOfEventsCapturedAfterRendering(
    incoming: Observable<Frame>,
    to drivers: Drivers
  ) -> Observable<Frame>
}

@UIApplicationMain class Example: CycledApplicationDelegate<MyRouter> {
  init() {
    super.init(router: MyRouter())
  }
}

struct MyRouter: IORouter {

  static let seed = AppModel()

  struct AppModel {
    let network = Network.Model()
    let screen = Screen.Model()
    let application = RxUIApplicationDelegate.Model()
  }
  
  struct Drivers: UIApplicationDelegateProviding, ScreenDrivable {
    let network: Network
    let screen: Screen // Anything that provides a 'root' UIViewController
    let application: RxUIApplicationDelegate // Anything that conforms to UIApplicationDelegate
  }

  func driversFrom(seed: AppModel) -> Drivers { return
    Drivers(
      network = Network(model: intitial.network),
      screen = Screen(model: intitial.screen),
      application = RxUIApplicationDelegate(model: initial.application)
    )
  }

  func effectsOfEventsCapturedAfterRendering(
    incoming: Observable<AppModel>,
    to drivers: Drivers
  ) -> Observable<AppModel> {

    let network = drivers
      .network
      .eventsCapturedAfterRendering(incoming.map { $0.network })
      .withLatestFrom(incoming) { ($0.0, $0.1) }
      .reducingFuctionOfYourChoice()

    let screen = drivers
      .screen
      .eventsCapturedAfterRendering(incoming.map { $0.screen })
      .withLatestFrom(incoming) { ($0.0, $0.1) }
      .reduced()

    let application = drivers
      .application
      .eventsCapturedAfterRendering(incoming.map { $0.application })
      .withLatestFrom(incoming) { ($0.0, $0.1) }
      .reduced()

    return Observable.merge([
      network,
      screen,
      application
    ])
  }

}

extension ObservableType where E == (Network.Model, AppModel) {
  func reducingFuctionOfYourChoice() -> Observable<AppModel> { return
    map { event, context in
      var new = context
      switch event.state {
        case .idle:
          new.screen.button.color = .blue
        case .awaitingStart, .awaitingResponse:
          new.screen.button.color = .grey
        default: 
          break
      }
      return new
    }
  }
}

extension ObservableType where E == (Screen.Model, AppModel) {
  func reduced() -> Observable<AppModel> { return
    map { event, context in
      var new = context
      switch event.button.state {
        case .highlighted:
          new.network.state = .awaitingStart
        default: 
          break
      }
      return new
    }
  }
}

extension ObservableType where E == (RxUIApplicationDelegate.Model, AppModel) {
  func reduced() -> Observable<AppModel> { return
    map { event, context in
      var new = context
      switch event.session.state {
        case .launching:
          new.screen = Screen.Model.downloadView
        default: 
          break
      }
      return new
    }
  }
}

class MyDriver {

  struct Model {
    var state: State
    enum State {
      case idle
      case sending
    }
  }
  
  enum Event {
    case receiving
  }

  fileprivate let output: BehaviorSubject<Model>
  
  // Pull-based interfaces (e.g. UITableViews) require retaining state.
  // State retention should be made as minimal as possible and well-guarded.
  fileprivate let model: Model

  public init(initial: Model) {
    model = initial
    output = BehaviorSubject<Model>(value: initial)
  }

  public func eventsCapturedAfterRendering(_ input: Observable<Model>) -> Observable<Event> { 
    input
      .subscribe(next: self.render)
      .disposed(by: cleanup)
    return self.output
  }

  func render(model: Model) {    
    if case .sending = model.state {
      // Perform side-effects...
    }
  }

  func didReceiveEvent() {
    output.on(.next(.receiving))
  }

}

func effectsOfEventsCapturedAfterRendering(
  incoming: Observable<[Frame]>,
  to drivers: Drivers
) -> Observable<[Frame]> {

  // Incoming models are rated-limited to 1/60th of a second
  let screenSynced = incoming.sample(
    Observable<Int>.interval(
      1.0 / 60.0,
      scheduler: MainScheduler.instance
    )
  )

  return Observable
    .merge([
      drivers
        .screen
        .eventsCapturedAfterRendering(screenSynced.map { $0.first! })
        // The state provided to the event-filter comes from the original,
        // non-rate-limited, incoming stream to ensure that the data 
        // provided isn't slightly stale the way data provided by the 
        // screenSynced stream might be.
        .withLatestFrom(incoming) { ($0.0, $0.1) }
        .animatedReducer()
      ,
      // The rest of the frames are sent back into the stream and the cycle repeats.
      screenSynced
        .withLatestFrom(incoming)
        .filter { $0.count > 1 }
        .map { $0.tail }
  ])
}