Merge pull request #36 from CombineCommunity/improve/feedback-dsl

Improve/feedback dsl

Author: twittemb

CHANGELOG.md

@@ -1,3 +1,7 @@
+**v0.3.0 - Tyranus**:
+
+- Feedback: introduce the "on:" keyword to explicitly declare the type of state that concerns the side effect
+
 **v0.2.0 - Vader**:
 
 - UISystem: unify the UISystem concept for RawState and ViewState

Examples/Examples.xcodeproj/project.pbxproj

@@ -626,8 +626,8 @@
 			isa = XCRemoteSwiftPackageReference;
 			repositoryURL = "[email protected]:twittemb/Feedbacks.git";
 			requirement = {
-				kind = exactVersion;
-				version = 0.2.0;
+				kind = revision;
+				revision = ceca7e90a065cbb67346d0234243f598500ddfc5;
 			};
 		};
 /* End XCRemoteSwiftPackageReference section */

Examples/Examples.xcodeproj/project.xcworkspace/xcshareddata/swiftpm/Package.resolved

@@ -19,8 +19,13 @@ extension CounterApp.System {
         }
 
         Feedbacks {
-            Feedback(strategy: .cancelOnNewState, sideEffect: CounterApp.SideEffects.decreaseEffect(state:))
-            Feedback(strategy: .cancelOnNewState, sideEffect: CounterApp.SideEffects.increaseEffect(state:))
+            Feedback(on: CounterApp.States.Decreasing.self,
+                     strategy: .cancelOnNewState,
+                     sideEffect: CounterApp.SideEffects.decreaseEffect(state:))
+
+            Feedback(on: CounterApp.States.Increasing.self,
+                     strategy: .cancelOnNewState,
+                     sideEffect: CounterApp.SideEffects.increaseEffect(state:))
         }
         .onStateReceived {
             print("Counter: New state has been received: \($0)")

Examples/Examples/CounterApp/System/CounterApp+System.swift

@@ -31,10 +31,10 @@ extension GifDetail.System {
             }
 
             Feedbacks {
-                Feedback(strategy: .cancelOnNewState, sideEffect: loadSideEffect)
+                Feedback(on: GifDetail.States.Loading.self, strategy: .cancelOnNewState, sideEffect: loadSideEffect)
                     .execute(on: DispatchQueue(label: "Load Gif Queue"))
 
-                Feedback(strategy: .cancelOnNewState, sideEffect: toggleFavoriteSideEffect)
+                Feedback(on: GifDetail.States.TogglingFavorite.self, strategy: .cancelOnNewState, sideEffect: toggleFavoriteSideEffect)
                     .execute(on: DispatchQueue(label: "Toggle Favorite Queue"))
             }
             .onStateReceived {

Examples/Examples/GiphyApp/Features/GifDetail/System/GifDetail+System.swift

@@ -25,7 +25,7 @@ extension GifList.System {
             }
 
             Feedbacks {
-                Feedback(strategy: .cancelOnNewState, sideEffect: loadSideEffect)
+                Feedback(on: GifList.States.Loading.self , strategy: .cancelOnNewState, sideEffect: loadSideEffect)
                     .execute(on: DispatchQueue(label: "Load Gifs Queue"))
             }
             .onStateReceived {

Examples/Examples/GiphyApp/Features/GifList/System/GifList+System.swift

@@ -37,15 +37,15 @@ let system = System {
     }
 
     Feedbacks {
-        Feedback(strategy: .continueOnNewState) { (state: VolumeState) -> AnyPublisher<Event, Never> in
+        Feedback(on: VolumeState.self, strategy: .continueOnNewState) { state -> AnyPublisher<Event, Never> in
             if state.value >= targetedVolume {
                 return Empty().eraseToAnyPublisher()
             }
 
             return Just(IncreaseEvent()).eraseToAnyPublisher()
         }
 
-        Feedback(strategy: .continueOnNewState) { (state: VolumeState) -> AnyPublisher<Event, Never> in
+        Feedback(on: VolumeState.self, strategy: .continueOnNewState) { state -> AnyPublisher<Event, Never> in
             if state.value <= targetedVolume {
                 return Empty().eraseToAnyPublisher()
             }
@@ -105,7 +105,7 @@ The declarative syntax of Feedbacks allows to alter the behavior of side effects
 
 ```swift
 Feedbacks {
-    Feedback(strategy: .continueOnNewState) { (state: LoadingState) -> AnyPublisher<Event, Never> in
+    Feedback(on: LoadingState.self, strategy: .continueOnNewState) { state -> AnyPublisher<Event, Never> in
         performLongRunningOperation()
 	        .map { FinishedLoadingEvent() }
 	        .eraseToAnyPublisher()
@@ -118,11 +118,11 @@ As in SwiftUI, modifiers can be applied to the container:
 
 ```swift
 Feedbacks {
-    Feedback(strategy: .continueOnNewState) { (state: LoadingState) -> AnyPublisher<Event, Never> in
+    Feedback(on: LoadingState.self, strategy: .continueOnNewState) { state -> AnyPublisher<Event, Never> in
     	...
     }
 
-    Feedback(strategy: .continueOnNewState) { (state: SelectedState) -> AnyPublisher<Event, Never> in
+    Feedback(on: SelectedState.self, strategy: .continueOnNewState) { state -> AnyPublisher<Event, Never> in
     	...
     }
 }
@@ -159,8 +159,8 @@ enum MySideEffects {
 
 let myNetworkService = MyNetworkService()
 let myDatabaseService = MyDatabaseService()
-let mySideEffect = SideEffect.make(MySideEffects.load, arg1: myNetworkService, arg2: myDatabaseService)
-let feedback = Feedback(strategy: .cancelOnNewState, sideEffect: mySideEffect)
+let loadingEffect = SideEffect.make(MySideEffects.load, arg1: myNetworkService, arg2: myDatabaseService)
+let feedback = Feedback(on: LoadingState.self, strategy: .cancelOnNewState, sideEffect: loadingEffect)
 ```
 
 `SideEffect.make()` factories will transform functions with several parameters (up to 6 including the state) into functions with 1 parameter (the state), on the condition of the state being the last one.
@@ -238,17 +238,17 @@ Everytime the RefreshEvent is received, this transition will produce a LoadingSt
 A Feedback is built from a side effect. A side effect is a function that takes a state as a parameter. There are two ways to build a Feedback:
 
 ```swift
-Feedback(strategy: .continueOnNewState) { (state: State) in
+Feedback(on: AnyState.self, strategy: .continueOnNewState) { state in
 	...
 	.map { _ in MyEvent() }
 	.eraseToAnyPublisher()
 }
 ```
 
-This feedback will execute the side effect for any type of state. It could be useful if you want to perform a side effect each time a new state is generated, regardless of the type of State.
+This feedback will execute the side effect whatever the type of state that is produced. It could be useful if you want to perform a side effect each time a new state is generated, regardless of the type of State.
 
 ```swift
-Feedback(strategy: .continueOnNewState) { (state: LoadingState) in
+Feedback(on: LoadingState.self, strategy: .continueOnNewState) { state in
 	...
 	.map { _ in MyEvent() }
 	.eraseToAnyPublisher()

README.md

@@ -18,6 +18,21 @@ public struct Feedback {
         case cancelOnNewState
         case continueOnNewState
 
+        func apply<StateType: State>(
+            on sideEffect: @escaping (StateType) -> AnyPublisher<Event, Never>,
+            willExecuteWithStrategy: @escaping (Feedback.Strategy) -> Void = { _ in }
+        ) -> (AnyPublisher<StateType, Never>) -> AnyPublisher<Event, Never> {
+            return { states in
+                willExecuteWithStrategy(self)
+                switch self {
+                case .cancelOnNewState:
+                    return states.map(sideEffect).switchToLatest().eraseToAnyPublisher()
+                case .continueOnNewState:
+                    return states.flatMap(sideEffect).eraseToAnyPublisher()
+                }
+            }
+        }
+
         func apply(
             on sideEffect: @escaping (State) -> AnyPublisher<Event, Never>,
             willExecuteWithStrategy: @escaping (Feedback.Strategy) -> Void = { _ in }
@@ -36,37 +51,55 @@ public struct Feedback {
 
     let sideEffect: (AnyPublisher<State, Never>) -> AnyPublisher<Event, Never>
 
-    /// Creates a Feedback based on a side effect to execute
-    /// - Parameter sideEffect: the side effect to execute in the context of this feedback
-    public init(sideEffect: @escaping (AnyPublisher<State, Never>) -> AnyPublisher<Event, Never>) {
+    init(sideEffect: @escaping (AnyPublisher<State, Never>) -> AnyPublisher<Event, Never>) {
         self.sideEffect = sideEffect
     }
 
+    /// Creates a Feedback based on a side effect to execute
+    /// - Parameters:
+    ///   - on: The type of state that should trigger the side effect (forced to AnyState)
+    ///   - sideEffect: the side effect to execute in the context of this feedback
+    public init(on: AnyState.Type,
+                sideEffect: @escaping (AnyPublisher<State, Never>) -> AnyPublisher<Event, Never>) {
+        self.init(sideEffect: sideEffect)
+    }
+
     /// Creates a Feedback based on a side effect that takes a generic State as an input.
     /// - Parameters:
+    ///   - on: The type of state that should trigger the side effect (forced to AnyState)
     ///   - strategy: when cancelOnNewState, the current side effect's execution will be canceled
     ///   - sideEffect: the side effect to execute in the context of the feedback
     /// - Returns: the feedback that stands for the side effect
-    public init(strategy: Feedback.Strategy,
+    public init(on: AnyState.Type,
+                strategy: Feedback.Strategy,
                 willExecuteWithStrategy: @escaping (Feedback.Strategy) -> Void = { _ in },
                 sideEffect: @escaping (State) -> AnyPublisher<Event, Never>) {
-        self.init(sideEffect: strategy.apply(on: sideEffect, willExecuteWithStrategy: willExecuteWithStrategy))
+        self.init(on: AnyState.self, sideEffect: strategy.apply(on: sideEffect, willExecuteWithStrategy: willExecuteWithStrategy))
     }
 
-    /// Creates a Feedback based on a side effect that takes a concrete State as an input.
+    /// Creates a Feedback based on a side effect to execute
     /// - Parameters:
+    ///   - on: The type of state that should trigger the side effect
+    ///   - sideEffect: the side effect to execute in the context of this feedback
+    public init<StateType: State>(on: StateType.Type,
+                                  sideEffect: @escaping (AnyPublisher<StateType, Never>) -> AnyPublisher<Event, Never>) {
+        let wrappingSideEffect: (AnyPublisher<State, Never>) -> AnyPublisher<Event, Never> = { states in
+            sideEffect(states.compactMap { $0 as? StateType }.eraseToAnyPublisher())
+        }
+        self.sideEffect = wrappingSideEffect
+    }
+
+    /// Creates a Feedback based on a side effect that takes a generic State as an input.
+    /// - Parameters:
+    ///   - on: The type of state that should trigger the side effect
     ///   - strategy: when cancelOnNewState, the current side effect's execution will be canceled
     ///   - sideEffect: the side effect to execute in the context of the feedback
     /// - Returns: the feedback that stands for the side effect
-    public init<StateType: State>(strategy: Feedback.Strategy,
-                                  willExecuteWithStrategy: @escaping (Feedback.Strategy) -> Void = { _ in },
-                                  sideEffect: @escaping (StateType) -> AnyPublisher<Event, Never>) {
-        let wrappingSideEffect: (State) -> AnyPublisher<Event, Never> = { state in
-            guard let concreteState = state as? StateType else { return Empty().eraseToAnyPublisher() }
-            return sideEffect(concreteState)
-        }
-
-        self.init(strategy: strategy, willExecuteWithStrategy: willExecuteWithStrategy, sideEffect: wrappingSideEffect)
+    public init<StateType: State>(on: StateType.Type,
+                strategy: Feedback.Strategy,
+                willExecuteWithStrategy: @escaping (Feedback.Strategy) -> Void = { _ in },
+                sideEffect: @escaping (StateType) -> AnyPublisher<Event, Never>) {
+        self.init(on: StateType.self, sideEffect: strategy.apply(on: sideEffect, willExecuteWithStrategy: willExecuteWithStrategy))
     }
 }
 

Sources/Feedbacks/System/Feedback.swift

@@ -135,9 +135,13 @@ public extension Feedbacks {
     /// - Parameter perform: the middleware to execute
     /// - Returns: the Feedbacks that executes the middleware before executing the side effects
     func onStateReceived(_ perform: @escaping (State) -> Void) -> Feedbacks {
-        let stateReceivedFeedback = Feedback(strategy: .continueOnNewState) { (state: State) in
-            perform(state)
-            return Empty().eraseToAnyPublisher()
+        let stateReceivedFeedback = Feedback { (states: AnyPublisher<State, Never>) in
+            states
+                .handleEvents(receiveOutput: perform)
+                .flatMap { _ in
+                    Empty<Event, Never>().eraseToAnyPublisher()
+                }
+                .eraseToAnyPublisher()
         }
 
         let newFeedbacks = self.feedbacks + [stateReceivedFeedback]