Cleanup comments and added missing @inlinable

Author: StevenLambion

Sources/SwiftDux/Action/Action.swift

@@ -33,10 +33,16 @@ public protocol RunnableAction: Action {
 
  /// When the action is dispatched to a store, this method will be called to handle
  /// any logic by the action.
+ ///
  /// - Parameter store: The store that the action has been dispatched to.
  /// - Returns: An optional cancellable.
  func run<T>(store: Store<T>) -> AnyCancellable?
 
+ /// Send an action that can be cancelled.
+ ///
+ /// - Parameter dispatcher: The send function that dispatches an action.
+ /// - Returns: AnyCancellable to cancel the action plan.
+ func sendAsCancellable(_ dispatcher: ActionDispatcher) -> AnyCancellable
 }
 
 /// A noop action used by reducers that may not have their own actions.

Sources/SwiftDux/Action/ActionDispatcher.swift

@@ -7,20 +7,23 @@ import Foundation
 /// solely on changes to the state of the application to respond.
 public protocol ActionDispatcher {
 
- /// Sends an action to a reducer to mutate the state of the application.
+ /// Sends an action to mutate the application state.
+ ///
  /// - Parameter action: An action to dispatch to the store.
  func send(_ action: Action)
 }
 
 extension ActionDispatcher {
 
- /// Sends an action to a reducer to mutate the state of the application.
+ /// Sends an action to mutate the application state.
+ ///
  /// - Parameter action: An action to dispatch to the store
  @inlinable public func callAsFunction(_ action: Action) {
  send(action)
  }
 
  /// Send an action plan that returns a cancellable object.
+ ///
  /// - Parameter actionPlan: The action
  /// - Returns: A cancellable to cancel the action.
  @inlinable public func sendAsCancellable<T>(_ actionPlan: ActionPlan<T>) -> AnyCancellable {

Sources/SwiftDux/Action/ActionPlan.swift

@@ -131,7 +131,6 @@ public struct ActionPlan<State>: RunnableAction {
  /// func signUp() {
  /// signUpCancellable = signUpActionPlan(username: username, password: password).sendAsCancellable(dispatch)
  /// }
- ///
  /// }
  /// ```
  ///

Sources/SwiftDux/Middleware/CombinedMiddleware.swift

@@ -11,7 +11,7 @@ public struct CombinedMiddleware<State, A, B>: Middleware where A: Middleware, B
  }
 
  /// Unimplemented. It simply calls `store.next(_:)`.
- public func run(store: StoreProxy<State>, action: Action) {
+ @inlinable public func run(store: StoreProxy<State>, action: Action) {
  store.next(action)
  }
 

Sources/SwiftDux/Reducer/Reducer.swift

@@ -40,7 +40,6 @@ public protocol Reducer {
  /// - action: Any kind of action.
  /// - Returns: A new immutable state
  func reduceAny(state: State, action: Action) -> State
-
 }
 
 extension Reducer {
@@ -85,11 +84,12 @@ extension Reducer {
  }
 
  /// Compose two reducers together.
+ ///
  /// - Parameters:
  /// - previousReducer: The first reducer to be called.
  /// - nextReducer: The second reducer to be called.
  /// - Returns: A combined reducer.
- public static func + <R>(previousReducer: Self, _ nextReducer: R) -> CombinedReducer<State, Self, R> where R: Reducer, R.State == State {
+ @inlinable public static func + <R>(previousReducer: Self, _ nextReducer: R) -> CombinedReducer<State, Self, R> where R: Reducer, R.State == State {
  CombinedReducer(previousReducer: previousReducer, nextReducer: nextReducer)
  }
 }

Sources/SwiftDux/Store/StateStorable.swift

@@ -3,14 +3,15 @@ import Foundation
 
 /// Represents a storable container for a state object.
 ///
-/// Extend this protocol to implement new methods for the Store<_> and StoreProxy<_>.
+/// Extend this protocol to implement new methods for the Store<_> and StoreProxy<_> types.
 public protocol StateStorable {
+ /// The type of the stored state object.
  associatedtype State
 
- /// Retrieves the latest state from the store.
+ /// The latest state of the store.
  var state: State { get }
 
- /// Emits after the specified action was sent to the store.
+ /// Emits after the state has been changed.
  var didChange: StorePublisher { get }
 }
 

Sources/SwiftDux/Store/Store.swift

@@ -1,28 +1,25 @@
 import Combine
 import Foundation
 
-/// The primary container of an application's state.
-///
-/// The store both contains and mutates the state through a provided reducer as it's sent actions.
-/// Use the didChange publisher to be notified of changes.
+/// Stores and mutates the state of an application.
 public final class Store<State>: StateStorable {
 
- /// The current state of the store. Use actions to mutate it.
+ /// The current state of the store.
  public private(set) var state: State {
  didSet { didChange.send() }
  }
 
- /// Subscribe for state changes. It emits the latest action sent to the store.
+ /// Publishes when the state has changed.
  public let didChange = StorePublisher()
 
  @usableFromInline
  internal var reduce: SendAction = { _ in }
 
- /// Creates a new store for the given state and reducer.
+ /// Initiates a new store for the given state and reducer.
  ///
  /// - Parameters
- /// - state: The initial state of the store. A typically use case is to restore a previous application session with a persisted state object.
- /// - reducer: A reducer that will mutate the store's state as actions are dispatched to it.
+ /// - state: The initial state of the store.
+ /// - reducer: A reducer that mutates the state as actions are dispatched to it.
  /// - middleware: A middleware plugin.
  public init<R, M>(state: State, reducer: R, middleware: M) where R: Reducer, R.State == State, M: Middleware, M.State == State {
  let storeReducer = StoreReducer(rootReducer: reducer)
@@ -41,24 +38,25 @@ public final class Store<State>: StateStorable {
  send(StoreAction<State>.prepare)
  }
 
- /// Creates a new store for the given state and reducer.
+ /// Initiates a new store for the given state and reducer.
  ///
  /// - Parameters
- /// - state: The initial state of the store. A typically use case is to restore a previous application session with a persisted state object.
- /// - reducer: A reducer that will mutate the store's state as actions are dispatched to it.
+ /// - state: The initial state of the store.
+ /// - reducer: A reducer that mutates the state as actions are dispatched to it.
  public convenience init<R>(state: State, reducer: R) where R: Reducer, R.State == State {
  self.init(state: state, reducer: reducer, middleware: NoopMiddleware())
  }
 
- /// Create a proxy of the store for a given type that it adheres to.
+ /// Create a proxy of the store for a given type or protocol.
+ ///
  /// - Parameters:
  /// - stateType: The type of state for the proxy. This must be a type that the store adheres to.
  /// - done: A closure called with an async action has completed.
  /// - Returns: A proxy object if the state type matches, otherwise nil.
  @inlinable public func proxy<T>(for stateType: T.Type, done: (() -> Void)? = nil) -> StoreProxy<T>? {
  guard state is T else { return nil }
  return StoreProxy<T>(
- getState: { [unowned self] in self.state as! T },
+ getState: { self.state as! T },
  didChange: didChange,
  dispatcher: self,
  done: done
@@ -68,8 +66,9 @@ public final class Store<State>: StateStorable {
 
 extension Store: ActionDispatcher {
 
- /// Sends an action to the store to mutate its state.
- /// - Parameter action: The action to mutate the state.
+ /// Sends an action to mutate the state.
+ ///
+ /// - Parameter action: The action to perform.
  @inlinable public func send(_ action: Action) {
  if let action = action as? RunnableAction {
  _ = action.run(store: self)

Sources/SwiftDux/Store/StoreProxy.swift

@@ -53,22 +53,24 @@ public struct StoreProxy<State>: StateStorable, ActionDispatcher {
  self.doneBlock = done ?? proxy.doneBlock
  }
 
- /// Send an action to the store.
+ /// Sends an action to mutate the application state.
+ ///
  /// - Parameter action: The action to send
  @inlinable public func send(_ action: Action) {
  dispatcher.send(action)
  }
 
- /// Use this in middleware to send an action to the next
- /// step in the pipeline. Outside of middleware, it does nothing.
+ /// Passes an action to the next middleware.
+ ///
+ /// Outside of the middleware pipeline this method does nothing.
  /// - Parameter action: The action to send
  @inlinable public func next(_ action: Action) {
  nextBlock?(action)
  }
 
- /// Used by action plans to tell the store that a publisher has completed or cancelled its work.
- /// Only use this if the action plan is not returning a publisher or subscribing via ActionSubscriber.
- /// This is not needed by action plans that don't return a cancellable.
+ /// Used by runnable action to tell the store that a publisher has completed or cancelled its work.
+ ///
+ /// Only use this if the action returns a cancellable object without using ActionSubscriber.
  @inlinable public func done() {
  doneBlock?()
  }

Sources/SwiftDux/Store/StoreReducer.swift

@@ -1,10 +1,10 @@
 import Foundation
 
-/// Actions performed for the store itself.
+/// Actions performed by the store itself.
 public enum StoreAction<State>: Action {
 
  /// Called at the initialization step of the store to allow reducers and middleware an oppertunity
- /// to set up configurations  Store actions may be dispatched at this stage, but other middleware
+ /// to set up configurations. Store actions may be dispatched at this stage, but other middleware
  /// and reducers might not be ready yet if they require any preparation themselves.
  case prepare