wip

Sources/ComposableArchitecture/Core.swift

@@ -0,0 +1,251 @@
+import Combine
+import Foundation
+
+@MainActor
+protocol Core<State, Action>: AnyObject, Sendable {
+  associatedtype State
+  associatedtype Action
+  var state: State { get }
+  func send(_ action: Action) -> Task<Void, Never>?
+
+  var didSet: CurrentValueRelay<Void> { get }
+}
+
+final class InvalidCore<State, Action>: Core {
+  var state: State {
+    get { fatalError() }
+    set { fatalError() }
+  }
+  func send(_ action: Action) -> Task<Void, Never>? { nil }
+
+  let didSet = CurrentValueRelay<Void>(())
+}
+
+final class RootCore<Root: Reducer>: Core {
+  var state: Root.State {
+    didSet {
+      didSet.send(())
+    }
+  }
+  let reducer: Root
+  var bufferedActions: [Root.Action] = []
+  let didSet = CurrentValueRelay(())
+  var effectCancellables: [UUID: AnyCancellable] = [:]
+  private var isSending = false
+  init(
+    initialState: Root.State,
+    reducer: Root
+  ) {
+    self.state = initialState
+    self.reducer = reducer
+  }
+  func send(_ action: Root.Action) -> Task<Void, Never>? {
+    _withoutPerceptionChecking {
+      send(action, originatingFrom: nil)
+    }
+  }
+  func send(_ action: Root.Action, originatingFrom originatingAction: Any?) -> Task<Void, Never>? {
+    self.bufferedActions.append(action)
+    guard !self.isSending else { return nil }
+
+    self.isSending = true
+    var currentState = self.state
+    let tasks = LockIsolated<[Task<Void, Never>]>([])
+    defer {
+      withExtendedLifetime(self.bufferedActions) {
+        self.bufferedActions.removeAll()
+      }
+      self.state = currentState
+      self.isSending = false
+      if !self.bufferedActions.isEmpty {
+        if let task = self.send(
+          self.bufferedActions.removeLast(),
+          originatingFrom: originatingAction
+        ) {
+          tasks.withValue { $0.append(task) }
+        }
+      }
+    }
+
+    var index = self.bufferedActions.startIndex
+    while index < self.bufferedActions.endIndex {
+      defer { index += 1 }
+      let action = self.bufferedActions[index]
+      let effect = reducer.reduce(into: &currentState, action: action)
+
+      switch effect.operation {
+      case .none:
+        break
+      case let .publisher(publisher):
+        var didComplete = false
+        let boxedTask = Box<Task<Void, Never>?>(wrappedValue: nil)
+        let uuid = UUID()
+        let effectCancellable = withEscapedDependencies { continuation in
+          publisher
+            .receive(on: UIScheduler.shared)
+            .handleEvents(receiveCancel: { [weak self] in self?.effectCancellables[uuid] = nil })
+            .sink(
+              receiveCompletion: { [weak self] _ in
+                boxedTask.wrappedValue?.cancel()
+                didComplete = true
+                self?.effectCancellables[uuid] = nil
+              },
+              receiveValue: { [weak self] effectAction in
+                guard let self else { return }
+                if let task = continuation.yield({
+                  self.send(effectAction, originatingFrom: action)
+                }) {
+                  tasks.withValue { $0.append(task) }
+                }
+              }
+            )
+        }
+
+        if !didComplete {
+          let task = Task<Void, Never> { @MainActor in
+            for await _ in AsyncStream<Void>.never {}
+            effectCancellable.cancel()
+          }
+          boxedTask.wrappedValue = task
+          tasks.withValue { $0.append(task) }
+          self.effectCancellables[uuid] = effectCancellable
+        }
+      case let .run(priority, operation):
+        withEscapedDependencies { continuation in
+          let task = Task(priority: priority) { @MainActor in
+            let isCompleted = LockIsolated(false)
+            defer { isCompleted.setValue(true) }
+            await operation(
+              Send { effectAction in
+                if isCompleted.value {
+                  reportIssue(
+                    """
+                    An action was sent from a completed effect:
+
+                      Action:
+                        \(debugCaseOutput(effectAction))
+
+                      Effect returned from:
+                        \(debugCaseOutput(action))
+
+                    Avoid sending actions using the 'send' argument from 'Effect.run' after \
+                    the effect has completed. This can happen if you escape the 'send' \
+                    argument in an unstructured context.
+
+                    To fix this, make sure that your 'run' closure does not return until \
+                    you're done calling 'send'.
+                    """
+                  )
+                }
+                if let task = continuation.yield({
+                  self.send(effectAction, originatingFrom: action)
+                }) {
+                  tasks.withValue { $0.append(task) }
+                }
+              }
+            )
+          }
+          tasks.withValue { $0.append(task) }
+        }
+      }
+    }
+
+    guard !tasks.isEmpty else { return nil }
+    return Task { @MainActor in
+      await withTaskCancellationHandler {
+        var index = tasks.startIndex
+        while index < tasks.endIndex {
+          defer { index += 1 }
+          await tasks[index].value
+        }
+      } onCancel: {
+        var index = tasks.startIndex
+        while index < tasks.endIndex {
+          defer { index += 1 }
+          tasks[index].cancel()
+        }
+      }
+    }
+  }
+  private actor DefaultIsolation {}
+}
+
+class ScopedCore<Base: Core, State, Action>: Core {
+  var base: Base
+  let stateKeyPath: KeyPath<Base.State, State>
+  let actionKeyPath: CaseKeyPath<Base.Action, Action>
+  init(
+    base: Base,
+    stateKeyPath: KeyPath<Base.State, State>,
+    actionKeyPath: CaseKeyPath<Base.Action, Action>
+  ) {
+    self.base = base
+    self.stateKeyPath = stateKeyPath
+    self.actionKeyPath = actionKeyPath
+  }
+  var state: State {
+    base.state[keyPath: stateKeyPath]
+  }
+  func send(_ action: Action) -> Task<Void, Never>? {
+    base.send(actionKeyPath(action))
+  }
+  var didSet: CurrentValueRelay<Void> {
+    base.didSet
+  }
+}
+
+class IfLetCore<Base: Core, State, Action>: Core {
+  var base: Base
+  var cachedState: State
+  let stateKeyPath: KeyPath<Base.State, State?>
+  let actionKeyPath: CaseKeyPath<Base.Action, Action>
+  init(
+    base: Base,
+    cachedState: State,
+    stateKeyPath: KeyPath<Base.State, State?>,
+    actionKeyPath: CaseKeyPath<Base.Action, Action>
+  ) {
+    self.base = base
+    self.cachedState = cachedState
+    self.stateKeyPath = stateKeyPath
+    self.actionKeyPath = actionKeyPath
+  }
+  var state: State {
+    base.state[keyPath: stateKeyPath] ?? cachedState
+  }
+  func send(_ action: Action) -> Task<Void, Never>? {
+    #if DEBUG
+      if BindingLocal.isActive && base.state[keyPath: stateKeyPath] == nil {
+        return nil
+      }
+    #endif
+    return base.send(actionKeyPath(action))
+  }
+  var didSet: CurrentValueRelay<Void> {
+    base.didSet
+  }
+}
+
+class ClosureScopedCore<Base: Core, State, Action>: Core {
+  var base: Base
+  let toState: (Base.State) -> State
+  let fromAction: (Action) -> Base.Action
+  init(
+    base: Base,
+    toState: @escaping (Base.State) -> State,
+    fromAction: @escaping (Action) -> Base.Action
+  ) {
+    self.base = base
+    self.toState = toState
+    self.fromAction = fromAction
+  }
+  var state: State {
+    toState(base.state)
+  }
+  func send(_ action: Action) -> Task<Void, Never>? {
+    base.send(fromAction(action))
+  }
+  var didSet: CurrentValueRelay<Void> {
+    base.didSet
+  }
+}

Sources/ComposableArchitecture/Effect.swift

@@ -1,10 +1,10 @@
-import Combine
+@preconcurrency import Combine
 import Foundation
 import SwiftUI
 
-public struct Effect<Action> {
+public struct Effect<Action>: Sendable {
   @usableFromInline
-  enum Operation {
+  enum Operation: Sendable {
     case none
     case publisher(AnyPublisher<Action, Never>)
     case run(TaskPriority? = nil, @Sendable (_ send: Send<Action>) async -> Void)

Sources/ComposableArchitecture/Internal/CurrentValueRelay.swift

@@ -1,7 +1,7 @@
 import Combine
 import Foundation
 
-final class CurrentValueRelay<Output>: Publisher {
+final class CurrentValueRelay<Output>: Publisher, @unchecked Sendable {
   typealias Failure = Never
 
   private var currentValue: Output

Sources/ComposableArchitecture/Observation/IdentifiedArray+Observation.swift

@@ -119,17 +119,30 @@ public struct _StoreCollection<ID: Hashable & Sendable, State, Action>: RandomAc
       else {
         return Store()
       }
-      let id = self.data.ids[position]
-      var element = self.data[position]
-      return self.store.scope(
-        id: self.store.id(state: \.[id:id]!, action: \.[id:id]),
-        state: ToState {
-          element = $0[id: id] ?? element
-          return element
-        },
-        action: { .element(id: id, action: $0) },
-        isInvalid: { !$0.ids.contains(id) }
+      let elementID = self.data.ids[position]
+      let scopeID = ScopeID<IdentifiedArray<ID, State>, IdentifiedAction<ID, Action>>(
+        state: \.[id:elementID], action: \.[id:elementID]
       )
+      guard let child = self.store.children[scopeID] as? Store<State, Action>
+      else {
+        @MainActor
+        func open(
+          _ core: some Core<IdentifiedArray<ID, State>, IdentifiedAction<ID, Action>>
+        ) -> Store<State, Action> {
+          let child = Store<State, Action>(
+            core: IfLetCore(
+              base: core,
+              cachedState: self.data[position],
+              stateKeyPath: \.[id:elementID],
+              actionKeyPath: \.[id:elementID]
+            )
+          )
+          self.store.children[scopeID] = child
+          return child
+        }
+        return open(self.store.core)
+      }
+      return child
     }
   }
 }

Sources/ComposableArchitecture/Observation/NavigationStack+Observation.swift

@@ -187,30 +187,50 @@ public struct _NavigationDestinationViewModifier<
     content
       .environment(\.navigationDestinationType, State.self)
       .navigationDestination(for: StackState<State>.Component.self) { component in
-        var element = component.element
-        self
-          .destination(
-            self.store.scope(
-              id: self.store.id(
-                state:
-                  \.[
-                    id:component.id,fileID:_HashableStaticString(
-                      rawValue: fileID),filePath:_HashableStaticString(
-                        rawValue: filePath),line:line,column:column
-                  ],
-                action: \.[id:component.id]
-              ),
-              state: ToState {
-                element = $0[id: component.id] ?? element
-                return element
-              },
-              action: { .element(id: component.id, action: $0) },
-              isInvalid: { !$0.ids.contains(component.id) }
-            )
-          )
+        navigationDestination(component: component)
           .environment(\.navigationDestinationType, State.self)
       }
   }
+
+  private func navigationDestination(component: StackState<State>.Component) -> Destination {
+    let id = store.id(
+      state:
+        \.[
+          id:component.id,
+          fileID:_HashableStaticString(rawValue: fileID),
+          filePath:_HashableStaticString(rawValue: filePath),
+          line:line,
+          column:column
+        ],
+      action: \.[id:component.id]
+    )
+    if let child = store.children[id] as? Store<State, Action> {
+      return destination(child)
+    } else {
+      @MainActor
+      func open(
+        _ core: some Core<StackState<State>, StackAction<State, Action>>
+      ) -> Destination {
+        let child = Store<State, Action>(
+          core: IfLetCore(
+            base: core,
+            cachedState: component.element,
+            stateKeyPath: \.[
+              id:component.id,
+              fileID:_HashableStaticString(rawValue: fileID),
+              filePath:_HashableStaticString(rawValue: filePath),
+              line:line,
+              column:column
+            ],
+            actionKeyPath: \.[id:component.id]
+          )
+        )
+        store.children[id] = child
+        return destination(child)
+      }
+      return open(store.core)
+    }
+  }
 }
 
 @available(iOS 16, macOS 13, tvOS 16, watchOS 9, *)