wip

Author: Ryu0118

Sources/SimplexArchitecture/Effect/CombineAction.swift

@@ -28,6 +28,7 @@ public extension CombineAction {
         .init(kind: .viewAction(action: action))
     }
 
+    @_disfavoredOverload
     @inlinable
     static func action(
         _ action: Reducer.ReducerAction

Sources/SimplexArchitecture/Effect/SideEffect.swift

@@ -17,6 +17,7 @@ public struct SideEffect<Reducer: ReducerProtocol>: Sendable {
         case concurrentReducerAction([Reducer.ReducerAction])
         case serialCombineAction([CombineAction<Reducer>])
         case concurrentCombineAction([CombineAction<Reducer>])
+        case runEffects([SideEffect<Reducer>])
     }
 
     let kind: EffectKind
@@ -86,4 +87,9 @@ public extension SideEffect {
     static func serial(_ actions: CombineAction<Reducer>...) -> Self {
         .init(effectKind: .serialCombineAction(actions))
     }
+
+    @inlinable
+    static func runEffects(_ effects: [SideEffect<Reducer>]) -> Self {
+        .init(effectKind: .runEffects(effects))
+    }
 }

Sources/SimplexArchitecture/Reducer/DependenciesOverrideModifier.swift

@@ -1,21 +1,30 @@
 import Dependencies
 
-public struct _DependenciesOverrideModifier<Base: ReducerProtocol>: _ReducerModifier {
+public struct _DependenciesOverrideModifier<Base: ReducerProtocol>: ReducerModifier {
     public let base: Base
     public let override: (inout DependencyValues) -> Void
 
+    @usableFromInline
+    init(base: Base, override: @escaping (inout DependencyValues) -> Void) {
+        self.base = base
+        self.override = override
+    }
+
+    @inlinable
     public func reduce(into state: StateContainer<Base.Target>, action: Base.Action) -> SideEffect<Base> {
         withDependencies(override) {
             base.reduce(into: state, action: action)
         }
     }
 
+    @inlinable
     public func reduce(into state: StateContainer<Base.Target>, action: Base.ReducerAction) -> SideEffect<Base> {
         withDependencies(override) {
             base.reduce(into: state, action: action)
         }
     }
 
+    @inlinable
     public func dependency<Value>(
         _ keyPath: WritableKeyPath<DependencyValues, Value>,
         value: Value
@@ -28,6 +37,7 @@ public struct _DependenciesOverrideModifier<Base: ReducerProtocol>: _ReducerModi
 }
 
 public extension ReducerProtocol {
+    @inlinable
     func dependency<Value>(
         _ keyPath: WritableKeyPath<DependencyValues, Value>,
         value: Value

Sources/SimplexArchitecture/Reducer/ReducerModifier.swift

@@ -1,20 +1,13 @@
 import Foundation
 import Dependencies
 
-public protocol _ReducerModifier<Base> {
+public protocol ReducerModifier<Base> {
     associatedtype Base: ReducerProtocol
-    var base: Base { get }
     func reduce(into state: StateContainer<Base.Target>, action: Base.Action) -> SideEffect<Base>
-    /// Evolve the current state of ActionSendable to the next state.
-    ///
-    /// - Parameters:
-    ///   - state: Current state of ActionSendable and ReducerState. ReducerState can be accessed from the `reducerState` property of State..
-    ///   - action: A ReducerAction that can change the state of View and ReducerState.
-    /// - Returns: An `SideEffect` representing the side effects generated by the reducer.
     func reduce(into state: StateContainer<Base.Target>, action: Base.ReducerAction) -> SideEffect<Base>
 }
 
-public extension _ReducerModifier {
+public extension ReducerModifier {
     @inlinable
     func reduce(
         into state: StateContainer<Base.Target>,

Sources/SimplexArchitecture/Reducer/ReducerProtocol.swift

@@ -114,6 +114,8 @@ public protocol ReducerProtocol<Target> {
     ///   - action: A ReducerAction that can change the state of View and ReducerState.
     /// - Returns: An `SideEffect` representing the side effects generated by the reducer.
     func reduce(into state: StateContainer<Target>, action: ReducerAction) -> SideEffect<Self>
+
+    associatedtype Children = Never
 }
 
 public extension ReducerProtocol where ReducerAction == Never {

Sources/SimplexArchitecture/Store/Store.swift

@@ -37,14 +37,14 @@ public final class Store<Reducer: ReducerProtocol> {
         self.initialReducerState = initialReducerState
     }
 
-    public init<R: _ReducerModifier<Reducer>>(
+    public init<R: ReducerModifier<Reducer>>(
         reducer: R
     ) where Reducer.ReducerState == Never {
         self.reduce = reducer.reduce
     }
 
     /// Initialize `Store` with the given `Reducer` and initial `ReducerState`.
-    public init<R: _ReducerModifier<Reducer>>(
+    public init<R: ReducerModifier<Reducer>>(
         reducer: R,
         initialReducerState: @autoclosure @escaping () -> Reducer.ReducerState
     ) {
@@ -213,6 +213,11 @@ extension Store {
             }
             return [SendTask(task: task)]
 
+        case let .runEffects(effects):
+            return effects.reduce(into: [SendTask]()) { partialResult, effect in
+                partialResult += runEffect(effect, send: send)
+            }
+
         case .none:
             return []
         }

Tests/SimplexArchitectureTests/DependenciesOverrideModifierTests.swift

@@ -0,0 +1,53 @@
+@testable import SimplexArchitecture
+import SwiftUI
+import Dependencies
+import XCTest
+
+final class DependenciesOverrideModifierTests: XCTestCase {
+    func testModifier() async {
+        let base = BaseView(
+            store: Store(
+                reducer: _DependenciesOverrideModifier(base: BaseReducer()) {
+                    $0.test = .init(asyncThrows: {})
+                }
+            )
+        )
+        let container = base.store.setContainerIfNeeded(for: base, states: .init())
+        await base.send(.test).wait()
+        XCTAssertEqual(container.count, 1)
+    }
+}
+
+struct BaseReducer: ReducerProtocol {
+    enum Action {
+        case test
+        case callback
+    }
+
+    @Dependency(\.test) var test
+
+    func reduce(into state: StateContainer<BaseView>, action: Action) -> SideEffect<BaseReducer> {
+        switch action {
+        case .test:
+            return .run { send in
+                try await test.asyncThrows()
+                await send(.callback)
+            }
+        case .callback:
+            state.count += 1
+            return .none
+        }
+    }
+}
+
+@ScopeState
+struct BaseView: View {
+    @State var count: Int = 0
+    let store: Store<BaseReducer>
+
+    init(store: Store<BaseReducer> = .init(reducer: BaseReducer())) {
+        self.store = store
+    }
+
+    var body: some View { EmptyView() }
+}

Tests/SimplexArchitectureTests/ReducerTests.swift

@@ -99,9 +99,7 @@ final class ReducerTests: XCTestCase {
     func testDependencies() async {
         let testStore = TestView(
             store: .init(
-                reducer: TestReducer()
-                    .dependency(\.test, value: .init {})
-                ,
+                reducer: TestReducer().dependency(\.test, value: .init {}),
                 initialReducerState: .init()
             )
         ).testStore(states: .init())
@@ -231,3 +229,27 @@ private struct TestView: View {
         EmptyView()
     }
 }
+
+private struct MyReducer: ReducerProtocol {
+    enum Action {
+        case hoge
+    }
+
+    func reduce(into state: StateContainer<MyView>, action: Action) -> SideEffect<MyReducer> {
+        .none
+    }
+}
+
+@ScopeState
+private struct MyView: View {
+    @State var count = 0
+    let store: Store<MyReducer>
+
+    init(store: Store<MyReducer> = Store(reducer: MyReducer())) {
+        self.store = store
+    }
+
+    var body: some View {
+        EmptyView()
+    }
+}

Tests/SimplexArchitectureTests/TestUtilities.swift

@@ -0,0 +1,13 @@
+import Foundation
+
+typealias Original = @convention(thin) (UnownedJob) -> Void
+typealias Hook = @convention(thin) (UnownedJob, Original) -> Void
+
+private let _swift_task_enqueueGlobal_hook = dlsym(
+    dlopen(nil, 0), "swift_task_enqueueGlobal_hook"
+).assumingMemoryBound(to: Hook?.self)
+
+var swift_task_enqueueGlobal_hook: Hook? {
+    get { _swift_task_enqueueGlobal_hook.pointee }
+    set { _swift_task_enqueueGlobal_hook.pointee = newValue }
+}