The Elm Architecture in Swift (A sketch)

import Foundation

protocol ActionType {}
protocol StateType {}
protocol CommandType {}

// A protocol which describes the requirements for the Model/View/Update of the
// Elm Architecture. Very simply, it requires a type that implements three
// static functions.
protocol Component {
    // The actions which propagate from the view. The component is free to use
    // any type, but generally would be a custom `enum`
    associatedtype ComponentAction: ActionType

    // Much like the action type, state can be any type. Usually a struct, but
    // could easily be a scalar value like an `Int`.
    associatedtype ComponentState: StateType

    // The view type is paramaterised. We don't assume a view type in the
    // application. This allows any kind of UI-diffing framework to be plugged
    // in.
    associatedtype ComponentView

    // Generates the initial state used to bootstrap a component.
    static func initialState() -> ComponentState

    // Handles the current state and an action, generating a new state.
    static func update(state: ComponentState, action: ComponentAction) -> (ComponentState, CommandType?)

    // Accepts the state and outputs a view. The `dispatcher` is the mechanism
    // the views use to propagate actions.
    static func view(state: ComponentState, dispatcher: Dispatcher<ComponentAction>) -> ComponentView
}

// The app class sits at the root of the application and coordinates the
// dispatch of actions, updates and re-rendering views.
class App<Root: Component, ViewType>  where Root.ComponentView == ViewType {
    var state: Root.ComponentState

    init() {
        state = Root.initialState()
    }

    func dispatch(action: Root.ComponentAction) {
        let (update, command) = Root.update(state: state, action: action)
        self.state = update
    }

    func view() -> ViewType {
        return Root.view(state: state, dispatcher: Dispatcher { self.dispatch(action: $0) })
    }
}

// The dispatcher isn't super interesting, so let's just say it helps propagate
// actions.
struct Dispatcher<Input: ActionType> {
    private let closure: (Input) -> Void

    init(_ closure: @escaping (Input) -> Void) {
        self.closure = closure
    }

    func send(_ action: Input) {
        self.closure(action)
    }

    func wrap<A: ActionType>(wrapper: @escaping (A) -> Input) -> Dispatcher<A> {
        return Dispatcher<A> { a in
            return self.closure(wrapper(a))
        }
    }
}

struct Root: Component {
    // Each component defines it's own action and state types.
    typealias ComponentAction = Action
    typealias ComponentState = State
    // The type of the view is defined with an alias, so it can be an NSView,
    // UIView or for our example a String.
    typealias ComponentView = String

    // Here are the actions that can be sent from the root component.
    enum Action: ActionType {
        case begin
        // This case is for wrapping actions from the NavBar child component.
        case navBar(NavBar.Action)
    }

    // The root state, which in this example just wraps the NavBar state.
    struct State: StateType {
        let navBar: NavBar.State
    }

    static func initialState() -> State {
        return State(navBar: NavBar.initialState())
    }

    static func update(state: State, action: Action) -> (State, CommandType?) {
        switch action {
        case .begin:
            return (state, nil)
        case let .navBar(navAction):
            // Here we handle an action from the nav bar. This involves calling
            // the NavBar's update function.
            let (update, command)  = NavBar.update(state: state.navBar, action: navAction)
            return (State(navBar: update), command)
        }
    }

    static func view(state: State, dispatcher: Dispatcher<Action>) -> String {
        // We generate a new dispatcher which wraps the NavBar actions with
        // a root action. This allows the update function to handle and unpack it.
        let dispatcher = dispatcher.wrap { .navBar($0) }
        // Rendering the view is simple here since it's a string. You can see
        // how it is calling the NavBar's view function and passing it it's
        // state and the newly scoped dispatcher.
        return "Section: \(NavBar.view(state: state.navBar, dispatcher: dispatcher))"
    }
}

struct NavBar: Component {
    typealias ComponentAction = Action
    typealias ComponentState = State
    typealias ComponentView = String

    enum Action: ActionType {
        case selectBrowse
        case selectPlaying
        case selectSearch
    }

    struct State: StateType {
        enum Section {
            case browse
            case playing
            case search
        }

        let current: Section
    }

    static func initialState() -> State {
        return State(current: .browse)
    }

    static func update(state: State, action: Action) -> (State, CommandType?) {
        switch action {
        case .selectBrowse: return (State(current: .browse), nil)
        case .selectPlaying: return (State(current: .playing), nil)
        case .selectSearch: return (State(current: .search), nil)
        }
    }

    static func view(state: State, dispatcher: Dispatcher<Action>) -> String {
        return "\(state.current)"
    }
}

// Initialise the app with the root component and the view type.
let app = App<Root, String>()

// Render the initial view
let initial = app.view() // "Section: browse"

// Dispatch an action from the navbar
app.dispatch(action: Root.Action.navBar(.selectSearch))

// Re-render the view
let next = app.view() // "Section: search"