Scope only event type, and erase event type.

Author: andersio

Loop/LoopBox.swift

@@ -2,7 +2,7 @@ import ReactiveSwift
 
 internal class ScopedLoopBox<RootState, RootEvent, ScopedState, ScopedEvent>: LoopBoxBase<ScopedState, ScopedEvent> {
     override var producer: SignalProducer<ScopedState, Never> {
-        root.producer.map(value)
+        root.producer.map(extract)
     }
 
     override var lifetime: Lifetime {
@@ -11,20 +11,20 @@ internal class ScopedLoopBox<RootState, RootEvent, ScopedState, ScopedEvent>: Lo
 
     /// Loop Internal SPI
     override var _current: ScopedState {
-        root._current[keyPath: value]
+        extract(root._current)
     }
 
     private let root: LoopBoxBase<RootState, RootEvent>
-    private let value: KeyPath<RootState, ScopedState>
+    private let extract: (RootState) -> ScopedState
     private let eventTransform: (ScopedEvent) -> RootEvent
 
     init(
         root: LoopBoxBase<RootState, RootEvent>,
-        value: KeyPath<RootState, ScopedState>,
+        value: @escaping (RootState) -> ScopedState,
         event: @escaping (ScopedEvent) -> RootEvent
     ) {
         self.root = root
-        self.value = value
+        self.extract = value
         self.eventTransform = event
     }
 
@@ -33,12 +33,14 @@ internal class ScopedLoopBox<RootState, RootEvent, ScopedState, ScopedEvent>: Lo
     }
 
     override func scoped<S, E>(
-        to scope: KeyPath<ScopedState, S>,
+        to scope: @escaping (ScopedState) -> S,
         event: @escaping (E) -> ScopedEvent
     ) -> LoopBoxBase<S, E> {
+        let extract = self.extract
+
         return ScopedLoopBox<RootState, RootEvent, S, E>(
             root: self.root,
-            value: value.appending(path: scope),
+            value: { scope(extract($0)) },
             event: { [eventTransform] in eventTransform(event($0)) }
         )
     }
@@ -75,7 +77,7 @@ internal class RootLoopBox<State, Event>: LoopBoxBase<State, Event> {
     }
 
     override func scoped<S, E>(
-        to scope: KeyPath<State, S>,
+        to scope: @escaping (State) -> S,
         event: @escaping (E) -> Event
     ) -> LoopBoxBase<S, E> {
         ScopedLoopBox(root: self, value: scope, event: event)
@@ -108,7 +110,7 @@ internal class LoopBoxBase<State, Event> {
     func send(_ event: Event) { subclassMustImplement() }
 
     func scoped<S, E>(
-        to scope: KeyPath<State, S>,
+        to scope: @escaping (State) -> S,
         event: @escaping (E) -> Event
     ) -> LoopBoxBase<S, E> {
         subclassMustImplement()

Loop/Public/Loop.swift

@@ -46,13 +46,27 @@ public final class Loop<State, Event> {
     }
 
     public func scoped<ScopedState, ScopedEvent>(
-        to scope: KeyPath<State, ScopedState>,
+        to scope: @escaping (State) -> ScopedState,
         event: @escaping (ScopedEvent) -> Event
     ) -> Loop<ScopedState, ScopedEvent> {
         return Loop<ScopedState, ScopedEvent>(
             box: box.scoped(to: scope, event: event)
         )
     }
+
+    public func scoped<ScopedEvent>(
+        event: @escaping (ScopedEvent) -> Event
+    ) -> Loop<State, ScopedEvent> {
+        return Loop<State, ScopedEvent>(
+            box: box.scoped(to: { $0 }, event: event)
+        )
+    }
+
+    public func eraseEventType() -> Loop<State, Never> {
+        return Loop<State, Never>(
+            box: box.scoped(to: { $0 }, event: { _ in fatalError() })
+        )
+    }
 }
 
 extension Loop {
@@ -73,7 +87,7 @@ extension Loop {
         value: KeyPath<State, ScopedState>,
         event: @escaping (ScopedEvent) -> Event
     ) -> Loop<ScopedState, ScopedEvent> {
-        return scoped(to: value, event: event)
+        return scoped(to: { $0[keyPath: value] }, event: event)
     }
 
     @available(*, unavailable, message:"Loop now starts automatically.")

Loop/Public/SwiftUI/LoopBinding.swift

@@ -39,7 +39,7 @@ public struct LoopBinding<State, Event>: DynamicProperty {
     }
 
     public func scoped<ScopedState, ScopedEvent>(
-        to value: KeyPath<State, ScopedState>,
+        to value: @escaping (State) -> ScopedState,
         event: @escaping (ScopedEvent) -> Event
     ) -> LoopBinding<ScopedState, ScopedEvent> {
         LoopBinding<ScopedState, ScopedEvent>(loop.scoped(to: value, event: event))