     }
 }
 
+/**
+ Defines `Action` dispatch cabalities. Instances that conform to `Dispatch` are expected
+ to know how to dispatch `Actions`.
+ **/
+
 public protocol Dispatch {
+    /**
+     Dispatches an action.
+     - parameter action The action that'll be dispatched.
+    **/
     func dispatch(action: Action)
 }
 
 extension Dispatch {
+    /**
+     Executes a closure with an injected `dispatch` function. Useful for
+     asynchronous `Action` dispatching.
+     - parameter thunk The closure that will be executed with an injected `dispatch` function.
+     **/
     public func dispatch(thunk: (Action -> Void) -> Void) {
         thunk { self.dispatch($0) }
     }
 }
 
+/**
+ Defines a mutation descriptor. Are typically associated to application actions and operations.
+ **/
 public protocol Action {}
 
+/**
+ Instances that conform to `Publisher` are expected to know how to add
+ handlers that are provided with an associated object in response
+ to generic events.
+ **/
 public protocol Publisher {
     associatedtype Publishing
+    /**
+     Adds a handler to a generic event.
+     - parameter subscription The handler that will be called in response
+     to generic events.
+     - returns A closure that unsubscribes the provided subscription.
+    **/
     func subscribe(subscription: Publishing -> Void) -> Void -> Void
 }
 
 extension Publisher {
+    /**
+     Adds the handler defined by a `Subscriber` that is compatible with the
+     events defined by this `Publisher`.
+     - parameter subscriber The compatible `Subscriber`.
+     - returns A closure that unsubscribes the provided `Subscriber`.
+     **/
     public func subscribe <T: Subscriber where T.Publishing == Publishing> (subscriber subscriber: T) -> Void -> Void {
         return subscribe { newState in
             subscriber.receive(subscriber.select(newState))

}

extension Publisher where Self: Dispatch {
    func connection <T: Subscriber where T.Publishing == Publishing> (to subscriber: T) -> StateConnection {
        let dispatch = { self.dispatch($0) }
        let unsubscribe = self.subscribe(subscriber: subscriber)

    
    /**
     Initializes a `Store`.
     - parameter initialState The initial value of the application state in hold.
     - parameter reducer The root pure function that's responsible for transforming state according to `Actions`.
    **/
    public init (initialState: State, reducer: (State, Action) -> State) {
        reduce = reducer
