Add SideEffect type and update ActionLens

Author: Qata

Sources/RecombinePackage/Helpers/Bool.swift

@@ -0,0 +1,25 @@
+extension Bool {
+    func `if`<T>(true truth: @autoclosure () throws -> T, false falsity: @autoclosure () throws -> T) rethrows -> T {
+        if self {
+            return try truth()
+        } else {
+            return try falsity()
+        }
+    }
+
+    func `if`<T>(true value: @autoclosure () throws -> T?) rethrows -> T? {
+        if self {
+            return try value()
+        } else {
+            return nil
+        }
+    }
+
+    func `if`<T>(false value: @autoclosure () throws -> T?) rethrows -> T? {
+        if self {
+            return nil
+        } else {
+            return try value()
+        }
+    }
+}

Sources/RecombinePackage/Middleware.swift

@@ -16,7 +16,7 @@ public struct Middleware<State, RawAction, RefinedAction> {
 
     /// Create a `Middleware` out of multiple other `Middleware`.
     public init(_ middlewares: Self...) {
-        self = middlewares.reduce(.init()) { $0.concat($1) }
+        self = middlewares.reduce(.init()) { $0.appending($1) }
     }
 
     /// Initialises the middleware with a transformative function.
@@ -28,7 +28,7 @@ public struct Middleware<State, RawAction, RefinedAction> {
     }
 
     /// Concatenates the transform function of the passed `Middleware` onto the callee's transform.
-    public func concat(_ other: Self) -> Self {
+    public func appending(_ other: Self) -> Self {
         .init { state, action, dispatch in
             self.transform(state, action, dispatch).flatMap {
                 other.transform(state, $0, dispatch)

Sources/RecombinePackage/SideEffect.swift

@@ -0,0 +1,30 @@
+public struct SideEffect<RefinedAction> {
+    public typealias Function = ([RefinedAction]) -> Void
+    internal let closure: Function
+
+    /// Create a passthrough `SideEffect`.
+    public init() {
+        closure = { _ in }
+    }
+
+    /// Create a `SideEffect` out of multiple other `SideEffect`s.
+    public init(_ effects: Self...) {
+        self = effects.reduce(.init()) { $0.appending($1) }
+    }
+
+    /// Initialises the `SideEffect` with a transformative function.
+    /// - parameter closure: The function that receives actions.
+    public init(
+        _ closure: @escaping ([RefinedAction]) -> Void
+    ) {
+        self.closure = closure
+    }
+
+    /// Creates a `SideEffect` that will run both the callee and caller's closures when run.
+    public func appending(_ other: Self) -> Self {
+        .init { actions in
+            self.closure(actions)
+            other.closure(actions)
+        }
+    }
+}

Sources/RecombinePackage/Store/ActionLens.swift

@@ -1,21 +1,54 @@
 public struct ActionLens<RawAction, BaseRefinedAction, SubRefinedAction> {
-    let dispatchFunction: (ActionStrata<[RawAction], [SubRefinedAction]>) -> Void
+    public typealias Action = ActionStrata<[RawAction], [SubRefinedAction]>
+    let dispatchFunction: (Bool, Bool, [Action]) -> Void
 
-    public func callAsFunction<S: Sequence>(actions: S) where S.Element == SubRefinedAction {
-        dispatchFunction(.refined(.init(actions)))
+    public func callAsFunction<S: Sequence>(
+        serially: Bool = false,
+        collect: Bool = false,
+        actions: S
+    ) where S.Element == Action {
+        dispatchFunction(serially, collect, .init(actions))
     }
 
-    public func callAsFunction<S: Sequence>(actions: S) where S.Element == RawAction {
-        dispatchFunction(.raw(.init(actions)))
+    public func callAsFunction<S: Sequence>(
+        serially: Bool = false,
+        collect: Bool = false,
+        refined actions: S
+    ) where S.Element == SubRefinedAction {
+        dispatchFunction(serially, collect, [.refined(.init(actions))])
+    }
+
+    public func callAsFunction<S: Sequence>(
+        serially: Bool = false,
+        collect: Bool = false,
+        raw actions: S
+    ) where S.Element == RawAction {
+        dispatchFunction(serially, collect, [.raw(.init(actions))])
     }
 }
 
 public extension ActionLens {
-    func callAsFunction(actions: SubRefinedAction...) {
-        dispatchFunction(.refined(actions))
+    func callAsFunction(
+        serially: Bool = false,
+        collect: Bool = false,
+        actions: Action...
+    ) {
+        callAsFunction(serially: serially, collect: collect, actions: actions)
+    }
+
+    func callAsFunction(
+        serially: Bool = false,
+        collect: Bool = false,
+        refined actions: SubRefinedAction...
+    ) {
+        callAsFunction(serially: serially, collect: collect, refined: actions)
     }
 
-    func callAsFunction(actions: RawAction...) {
-        dispatchFunction(.raw(actions))
+    func callAsFunction(
+        serially: Bool = false,
+        collect: Bool = false,
+        raw actions: RawAction...
+    ) {
+        callAsFunction(serially: serially, collect: collect, raw: actions)
     }
 }

Sources/RecombinePackage/Store/BaseStore.swift

@@ -27,6 +27,7 @@ public class BaseStore<State: Equatable, RawAction, RefinedAction>: StoreProtoco
         reducer: R,
         middleware: Middleware<State, RawAction, RefinedAction> = .init(),
         thunk: Thunk<State, RawAction, RefinedAction> = .init { _, _ in Empty() },
+        sideEffect: SideEffect<RefinedAction> = .init(),
         publishOn scheduler: S
     ) where R.State == State, R.Action == RefinedAction {
         self.state = state
@@ -72,6 +73,9 @@ public class BaseStore<State: Equatable, RawAction, RefinedAction>: StoreProtoco
         group?.enter()
         DispatchQueue.global().async {
             self._postMiddlewareRefinedActions
+                .handleEvents(receiveOutput: {
+                    sideEffect.closure($0)
+                })
                 .scan(state) { state, actions in
                     actions.reduce(state, reducer.reduce)
                 }
@@ -123,12 +127,17 @@ public class BaseStore<State: Equatable, RawAction, RefinedAction>: StoreProtoco
         _actionsPairedWithState.eraseToAnyPublisher()
     }
 
+    /// Dispatch actions to the store.
+    ///
+    /// - parameter serially: Whether to resolve the actions concurrently or serially.
+    /// - parameter collect: Whether to collect all refined actions and send them when finished, or send them as they are resolved.
+    /// - parameter actions: The actions to be sent.
     open func dispatch<S: Sequence>(
         serially: Bool = false,
         collect: Bool = false,
         actions: S
     ) where S.Element == Action {
-        let maxPublishers: Subscribers.Demand = serially ? .max(1) : .unlimited
+        let maxPublishers: Subscribers.Demand = serially.if(true: .max(1), false: .unlimited)
         weak var `self` = self
 
         func recurse(actions: Action) -> AnyPublisher<[RefinedAction], Never> {
@@ -152,23 +161,19 @@ public class BaseStore<State: Equatable, RawAction, RefinedAction>: StoreProtoco
             maxPublishers: maxPublishers,
             recurse(actions:)
         )
-        let transformed: AnyPublisher<[RefinedAction], Never>
 
-        if collect {
-            transformed = recursed
+        collect.if(
+            true: recursed
                 .collect()
                 .map { $0.flatMap { $0 } }
+                .eraseToAnyPublisher(),
+            false: recursed
                 .eraseToAnyPublisher()
-        } else {
-            transformed = recursed
-                .eraseToAnyPublisher()
+        )
+        .sink {
+            self?._preMiddlewareRefinedActions.send($0)
         }
-
-        transformed
-            .sink {
-                self?._preMiddlewareRefinedActions.send($0)
-            }
-            .store(in: &cancellables)
+        .store(in: &cancellables)
     }
 
     open func injectBypassingMiddleware<S: Sequence>(actions: S) where S.Element == RefinedAction {

Sources/RecombinePackage/Store/StoreProtocol.swift

@@ -79,13 +79,19 @@ public extension StoreProtocol {
         BaseRefinedAction,
         SubRefinedAction
     > {
-        ActionLens {
-            switch $0 {
-            case let .raw(actions):
-                self.underlying.dispatch(raw: actions)
-            case let .refined(actions):
-                self.underlying.dispatch(refined: actions.map(self.actionPromotion))
-            }
+        ActionLens { [underlying, actionPromotion] serially, collect, actions in
+            underlying.dispatch(
+                serially: serially,
+                collect: collect,
+                actions: actions.map {
+                    switch $0 {
+                    case let .refined(actions):
+                        return .refined(actions.map(actionPromotion))
+                    case let .raw(actions):
+                        return .raw(actions)
+                    }
+                }
+            )
         }
     }
 }

Tests/RecombineTests/StoreMiddlewareTests.swift

@@ -12,7 +12,7 @@ class StoreMiddlewareTests: XCTestCase {
         let store = BaseStore(
             state: TestFakes.StringTest.State(),
             reducer: TestFakes.StringTest.reducer,
-            middleware: firstMiddleware.concat(secondMiddleware),
+            middleware: firstMiddleware.appending(secondMiddleware),
             thunk: .init(),
             publishOn: ImmediateScheduler.shared
         )

Tests/RecombineTests/StoreTests.swift

@@ -96,6 +96,7 @@ class DeInitStore<State: Equatable>: BaseStore<State, TestFakes.SetAction, TestF
         reducer: R,
         middleware _: Middleware<State, TestFakes.SetAction, TestFakes.SetAction> = .init(),
         thunk: Thunk<State, TestFakes.SetAction, TestFakes.SetAction> = .init(),
+        sideEffect _: SideEffect<TestFakes.SetAction> = .init(),
         publishOn scheduler: S
     ) where State == R.State, TestFakes.SetAction == R.Action, S: Scheduler, R: Reducer {
         super.init(