Merge pull request #19 from GoodRequest/feature/typeerasure

Type erasure + state mocks + concurrency improvements

Author: plajdo

Package.swift

@@ -46,11 +46,6 @@ let package = Package(
             name: "GoodReactorTests",
             dependencies: ["GoodReactor"],
             swiftSettings: [.swiftLanguageMode(.v6)]
-        ),
-        .testTarget(
-            name: "GoodCoordinatorTests",
-            dependencies: ["LegacyReactor"],
-            swiftSettings: [.swiftLanguageMode(.v6)]
         )
     ]
 )

Sources/GoodReactor/AnyReactor.swift

@@ -0,0 +1,128 @@
+//
+//  AnyReactor.swift
+//  GoodReactor
+//
+//  Created by Filip Šašala on 24/09/2025.
+//
+
+import Observation
+
+@available(iOS 17.0, macOS 14.0, *)
+@MainActor @Observable @dynamicMemberLookup public final class AnyReactor<WrappedAction: Sendable, WrappedMutation: Sendable, WrappedDestination: Sendable, WrappedState>: Reactor {
+
+    // MARK: - Type aliases
+
+    public typealias Action = WrappedAction
+    public typealias Mutation = WrappedMutation
+    public typealias Destination = WrappedDestination
+    public typealias State = WrappedState
+
+    // MARK: - Forwarders
+
+    private let _getState: () -> State
+    private let _setState: (State) -> ()
+    private let _initialStateBuilder: () -> State
+    private let _sendAction: (Action) -> ()
+    private let _sendActionAsync: (Action) async -> ()
+    private let _getDestination: () -> Destination?
+    private let _sendDestination: (Destination?) -> ()
+    private let _reduce: (inout State, Event<WrappedAction, WrappedMutation, WrappedDestination>) -> ()
+    private let _transform: () -> ()
+
+    // MARK: - Initialization
+
+    public init<R: Reactor>(_ base: R) where
+        R.Action == Action,
+        R.Mutation == Mutation,
+        R.Destination == Destination,
+        R.State == State
+    {
+        self._getState = { base.state }
+        self._setState = { base.state = $0 }
+        self._initialStateBuilder = { base.makeInitialState() }
+        self._sendAction = { base.send(action: $0) }
+        self._sendActionAsync = { await base.send(action: $0) }
+        self._getDestination = { base.destination }
+        self._sendDestination = { base.send(destination: $0) }
+        self._reduce = { base.reduce(state: &$0, event: $1) }
+        self._transform = { base.transform() }
+    }
+
+}
+
+// MARK: - Dynamic member lookup
+
+@available(iOS 17.0, macOS 14.0, *)
+public extension AnyReactor {
+
+    subscript<T>(dynamicMember keyPath: KeyPath<State, T>) -> T {
+        _getState()[keyPath: keyPath]
+    }
+
+    subscript<T>(dynamicMember keyPath: ReferenceWritableKeyPath<State, T>) -> T {
+        _getState()[keyPath: keyPath]
+    }
+
+}
+
+// MARK: - Reactor
+
+@available(iOS 17.0, macOS 14.0, *)
+public extension AnyReactor {
+
+    func makeInitialState() -> State {
+        _initialStateBuilder()
+    }
+
+    func transform() {
+        _transform()
+    }
+
+    func reduce(state: inout State, event: Event<WrappedAction, WrappedMutation, WrappedDestination>) {
+        _reduce(&state, event)
+    }
+
+    var destination: Destination? {
+        get {
+            _getDestination()
+        }
+        set {
+            _sendDestination(newValue)
+        }
+    }
+
+    var initialState: State {
+        _initialStateBuilder()
+    }
+
+}
+
+// MARK: - Mirror
+
+@available(iOS 17.0, macOS 14.0, *)
+public extension AnyReactor {
+
+    func send(action: Action) {
+        _sendAction(action)
+    }
+
+    func send(action: Action) async {
+        await _sendActionAsync(action)
+    }
+
+    func send(destination: Destination?) {
+        _sendDestination(destination)
+    }
+
+}
+
+// MARK: - Eraser
+
+@available(iOS 17.0, macOS 14.0, *)
+public extension Reactor {
+
+    func eraseToAnyReactor() -> AnyReactor<Action, Mutation, Destination, State> {
+        AnyReactor(self)
+    }
+
+}

Sources/GoodReactor/Event.swift

@@ -5,6 +5,10 @@
 //  Created by Filip Šašala on 27/08/2024.
 //
 
+import Foundation
+
+// MARK: - Event
+
 public final class Event<A, M, D>: Sendable where A: Sendable, M: Sendable, D: Sendable {
 
     public enum Kind: Sendable {
@@ -27,4 +31,39 @@ public final class Event<A, M, D>: Sendable where A: Sendable, M: Sendable, D: S
 
 }
 
-internal final class EventIdentifier: Identifier, Sendable {}
+// MARK: - Event task counter
+
+struct EventTaskCounter: Sendable {
+
+    var events: [EventIdentifier: Int] = [:]
+    
+    /// Checks if any tasks are running for provided event
+    /// - Parameter identifier: Event to check
+    /// - Returns: `true` if any tasks are running, `false` otherwise
+    func tasksActive(forEvent identifier: EventIdentifier) -> Bool {
+        return events.keys.contains(identifier)
+    }
+    
+    /// Increments task counter for provided event
+    /// - Parameter identifier: Event starting a new task
+    mutating func newTask(eventId identifier: EventIdentifier) {
+        events[identifier] = events[identifier, default: 0] + 1
+    }
+    
+    /// Decrements task counter for provided event
+    /// - Parameter identifier: Event stopping the task
+    /// - Returns: Number of remaining tasks
+    mutating func stopTask(eventId identifier: EventIdentifier) -> Int {
+        let taskCount = events[identifier, default: 0]
+        let newTaskCount = taskCount - 1
+
+        events[identifier] = newTaskCount
+
+        if newTaskCount < 1 {
+            events.removeValue(forKey: identifier)
+        }
+
+        return newTaskCount
+    }
+
+}

Sources/GoodReactor/Identifier.swift

@@ -32,3 +32,7 @@ public final class CodeLocationIdentifier: Identifier {
     }
 
 }
+
+// MARK: - Event identifier
+
+internal final class EventIdentifier: Identifier, Sendable {}

Sources/GoodReactor/MapTables.swift

@@ -7,31 +7,31 @@
 
 internal enum MapTables {
 
-    typealias AnyReactor = AnyObject
+    internal typealias ReactorType = AnyObject
 
     // State of a reactor
-    static let state = WeakMapTable<AnyReactor, Any>()
+    static let state = WeakMapTable<ReactorType, Any>()
 
     // Initial state of a reactor
-    static let initialState = WeakMapTable<AnyReactor, Any>()
+    static let initialState = WeakMapTable<ReactorType, Any>()
 
     // Number of currently running asynchronous tasks for an event of a reactor
-    static let runningEvents = WeakMapTable<AnyReactor, Set<EventIdentifier>>()
+    static let runningEvents = WeakMapTable<ReactorType, EventTaskCounter>()
 
     // Subscriptions of a reactor (new way)
-    static let subscriptions = WeakMapTable<AnyReactor, Set<AnyTask>>()
+    static let subscriptions = WeakMapTable<ReactorType, Set<AnyTask>>()
 
     // Debouncers of a reactor
-    static let debouncers = WeakMapTable<AnyReactor, Dictionary<DebouncerIdentifier, Any>>()
+    static let debouncers = WeakMapTable<ReactorType, Dictionary<DebouncerIdentifier, Any>>()
 
     // State stream cancellable (Combine)
-    static let stateStreams = WeakMapTable<AnyReactor, Any>()
+    static let stateStreams = WeakMapTable<ReactorType, Any>()
 
     // Event stream cancellable (Combine)
-    static let eventStreams = WeakMapTable<AnyReactor, Any>()
+    static let eventStreams = WeakMapTable<ReactorType, Any>()
 
     // Logger of a reactor
-    static let loggers = WeakMapTable<AnyReactor, ReactorLogger>()
+    static let loggers = WeakMapTable<ReactorType, ReactorLogger>()
 
     // Semaphore lock of an event (does not matter which reactor it's running on)
     static let eventLocks = WeakMapTable<EventIdentifier, AsyncSemaphore>()

Sources/GoodReactor/Reactor.swift

@@ -19,7 +19,7 @@ import SwiftUI
 
 // MARK: - Reactor protocol
 
-@MainActor @dynamicMemberLookup public protocol Reactor: AnyObject, Identifiable {
+@MainActor @dynamicMemberLookup public protocol Reactor: AnyObject, Identifiable, Hashable {
 
     /// Internal events
     ///
@@ -229,30 +229,6 @@ public extension Reactor {
 
 }
 
-// MARK: - Directly writable types
-
-public extension Reactor {
-
-    /// Opt-in writable accessor for value type paths (structs)
-    subscript<T: __ReactorDirectWriteable>(dynamicMember keyPath: WritableKeyPath<State, T>) -> T {
-        get {
-            state[keyPath: keyPath]
-        }
-        set {
-            var s = state
-            s[keyPath: keyPath] = newValue
-            state = s
-        }
-    }
-
-    /// Opt-in writable accessor for reference type paths (class members)
-    subscript<T: __ReactorDirectWriteable>(dynamicMember keyPath: ReferenceWritableKeyPath<State, T>) -> T {
-        get { state[keyPath: keyPath] }
-        set { state[keyPath: keyPath] = newValue }
-    }
-
-}
-
 // MARK: - Default implementation
 
 public extension Reactor {
@@ -379,14 +355,18 @@ public extension Reactor {
     /// and supply mutations using a ``Publisher`` and ``subscribe(to:map:)``
     @available(*, noasync) func run(_ event: Event, @_implicitSelfCapture eventHandler: @autoclosure @escaping () -> @Sendable () async -> Mutation?) {
         let semaphore = MapTables.eventLocks[key: event.id, default: AsyncSemaphore(value: 0)]
-        MapTables.runningEvents[key: self, default: []].insert(event.id)
+        MapTables.runningEvents[key: self, default: EventTaskCounter()].newTask(eventId: event.id)
 
         Task { @MainActor [weak self] in
             guard let self else { return }
 
             defer {
-                MapTables.runningEvents[key: self, default: []].remove(event.id)
-                semaphore.signal()
+                let remainingTasks = MapTables.runningEvents[key: self, default: EventTaskCounter()]
+                    .stopTask(eventId: event.id)
+
+                if remainingTasks < 1 {
+                    semaphore.signal()
+                }
             }
 
             let mutation = await Task.detached(operation: eventHandler()).value
@@ -531,7 +511,7 @@ private extension Reactor {
 
         _reduce(state: &state, event: event)
 
-        if MapTables.runningEvents[key: self, default: []].contains(eventId) {
+        if MapTables.runningEvents[key: self, default: EventTaskCounter()].tasksActive(forEvent: eventId) {
             try? await semaphore.waitUnlessCancelled()
         }
     }

Sources/GoodReactor/ReactorDirectWritable.swift

@@ -0,0 +1,48 @@
+//
+//  Stub.swift
+//  GoodReactor
+//
+//  Created by Filip Šašala on 24/09/2025.
+//
+
+import Observation
+
+/// Stub is a ``Reactor`` implementation adjusted for use in Xcode previews
+/// to mock different states of the UI. Stub resolves the state at initialization and
+/// supports small changes to state in its `reducer`.
+@available(iOS 17.0, macOS 14.0, *)
+@Observable public final class Stub<R: Reactor>: Reactor {
+
+    public typealias Event = R.Event
+    public typealias Action = R.Action
+    public typealias Mutation = R.Mutation
+    public typealias Destination = R.Destination
+    public typealias State = R.State
+
+    public var destination: R.Destination?
+    public var destinations: R.Destination.Type?
+
+    private let supplier: () -> (R.State)
+    private let reducer: ((inout R.State, Event) -> ())?
+
+    public func makeInitialState() -> R.State {
+        supplier()
+    }
+
+    public func reduce(state: inout R.State, event: Event) {
+        reducer?(&state, event)
+    }
+    
+    /// Initializes a Stub ``Reactor`` with state and a simple reducer.
+    /// - Parameters:
+    ///   - supplier: Closure supplying initial mocked state
+    ///   - reducer: Closure reducing small changes to mocked state
+    public init(
+        supplier: @escaping (() -> (R.State)),
+        reducer: ((inout R.State, Event) -> ())? = nil
+    ) {
+        self.supplier = supplier
+        self.reducer = reducer
+    }
+
+}