Segragate a substate mutation in a dedicated reducer

Author: twittemb

RxReduce.xcodeproj/project.pbxproj

@@ -7,6 +7,8 @@
 	objects = {
 
 /* Begin PBXBuildFile section */
+		1A26CF05212BA111008A6D7B /* Lens.swift in Sources */ = {isa = PBXBuildFile; fileRef = 1A26CF04212BA111008A6D7B /* Lens.swift */; };
+		1A26CF07212BA15D008A6D7B /* Reducer.swift in Sources */ = {isa = PBXBuildFile; fileRef = 1A26CF06212BA15D008A6D7B /* Reducer.swift */; };
 		1A2A7571208D4750009883BF /* RxReduce.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 1A2A7567208D474F009883BF /* RxReduce.framework */; };
 		1A2A7576208D4750009883BF /* ActionTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 1A2A7575208D4750009883BF /* ActionTests.swift */; };
 		1A2A7578208D4750009883BF /* RxReduce.h in Headers */ = {isa = PBXBuildFile; fileRef = 1A2A756A208D4750009883BF /* RxReduce.h */; settings = {ATTRIBUTES = (Public, ); }; };
@@ -49,6 +51,8 @@
 /* End PBXCopyFilesBuildPhase section */
 
 /* Begin PBXFileReference section */
+		1A26CF04212BA111008A6D7B /* Lens.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Lens.swift; sourceTree = "<group>"; };
+		1A26CF06212BA15D008A6D7B /* Reducer.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Reducer.swift; sourceTree = "<group>"; };
 		1A2A7567208D474F009883BF /* RxReduce.framework */ = {isa = PBXFileReference; explicitFileType = wrapper.framework; includeInIndex = 0; path = RxReduce.framework; sourceTree = BUILT_PRODUCTS_DIR; };
 		1A2A756A208D4750009883BF /* RxReduce.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = RxReduce.h; sourceTree = "<group>"; };
 		1A2A756B208D4750009883BF /* Info.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist.xml; path = Info.plist; sourceTree = "<group>"; };
@@ -112,6 +116,8 @@
 			children = (
 				1A2A756A208D4750009883BF /* RxReduce.h */,
 				1A2A7588208D51E2009883BF /* Action.swift */,
+				1A26CF04212BA111008A6D7B /* Lens.swift */,
+				1A26CF06212BA15D008A6D7B /* Reducer.swift */,
 				1A2A7589208D51E2009883BF /* Store.swift */,
 				1A2A756B208D4750009883BF /* Info.plist */,
 			);
@@ -278,6 +284,8 @@
 			files = (
 				1A2A758C208D51E2009883BF /* Store.swift in Sources */,
 				1A2A758B208D51E2009883BF /* Action.swift in Sources */,
+				1A26CF07212BA15D008A6D7B /* Reducer.swift in Sources */,
+				1A26CF05212BA111008A6D7B /* Lens.swift in Sources */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};

RxReduce/Lens.swift

@@ -0,0 +1,14 @@
+//
+//  Lens.swift
+//  RxReduce
+//
+//  Created by Thibault Wittemberg on 2018-08-20.
+//  Copyright © 2018 WarpFactor. All rights reserved.
+//
+
+import Foundation
+
+public struct Lens<State, SubState> {
+    let get: (State) -> SubState
+    let set: (State, SubState) -> State
+}

RxReduce/Reducer.swift

@@ -0,0 +1,18 @@
+//
+//  Reducer.swift
+//  RxReduce
+//
+//  Created by Thibault Wittemberg on 2018-08-20.
+//  Copyright © 2018 WarpFactor. All rights reserved.
+//
+
+import Foundation
+
+public struct Reducer<State: Equatable, SubState: Equatable> {
+    let lens: Lens<State, SubState>
+    let reducer: (State, Action) -> SubState
+
+    func apply(state: State, action: Action) -> State {
+        return self.lens.set(state, self.reducer(state, action))
+    }
+}

RxReduce/Store.swift

@@ -10,49 +10,53 @@ import Foundation
 import RxSwift
 import RxCocoa
 
-/// A Reducer mutates an input state into an output state according to an action
-public typealias Reducer<StateType: Equatable> = (_ state: StateType, _ action: Action) -> StateType
-
-/// A Middleware has not effect on the state, it us just triggered by a dispatch action
-public typealias Middleware<StateType: Equatable> = (_ state: StateType, _ action: Action) -> Void
+///// A Reducer mutates an input state into an output state according to an action
+//public typealias Reducer<StateType: Equatable> = (_ state: StateType, _ action: Action) -> StateType
+//
+///// A Middleware has not effect on the state, it us just triggered by a dispatch action
+//public typealias Middleware<StateType: Equatable> = (_ state: StateType, _ action: Action) -> Void
 
 /// A Store holds the state, mutate the state through actions / reducers and exposes the state via a Driver
 /// A Store is dedicated to a State Type
-public final class Store<StateType: Equatable> {
+public final class Store<State: Equatable> {
 
-    private var state: StateType
-    private let reducers: ContiguousArray<Reducer<StateType>>
-    private let middlewares: ContiguousArray<Middleware<StateType>>?
+    public typealias ReducerFunction = (State, Action) -> State
 
-    public init(withState state: StateType,
-                withReducers reducers: ContiguousArray<Reducer<StateType>>,
-                withMiddlewares middlewares: ContiguousArray<Middleware<StateType>>? = nil) {
+    private var state: State
+    private var reducers = [ReducerFunction]()
+//    private let reducers: ContiguousArray<Reducer<StateType>>
+//    private let middlewares: ContiguousArray<Middleware<StateType>>?
+
+    public init(withState state: State) {
         self.state = state
-        self.reducers = reducers
-        self.middlewares = middlewares
+//        self.middlewares = middlewares
+    }
+
+    public func register<SubState: Equatable> (reducer: Reducer<State, SubState>) {
+        self.reducers.append(reducer.apply)
     }
 
-    public func dispatch(action: Action) -> Observable<StateType> {
+    public func dispatch(action: Action) -> Observable<State> {
         // every received action is converted to an async action
         return action
             .toAsync()
-            .do(onNext: { [unowned self] (action) in
-                self.middlewares?.forEach({ [unowned self] (middleware) in
-                    middleware(self.state, action)
-                })
-            })
-            .map { (action) -> StateType in
-
-                return self.reducers.reduce(self.state, { (previousState, reducer) -> StateType in
-                    return reducer(previousState, action)
+//            .do(onNext: { [unowned self] (action) in
+//                self.middlewares?.forEach({ [unowned self] (middleware) in
+//                    middleware(self.state, action)
+//                })
+//            })
+            .map { (action) -> State in
+
+                return self.reducers.reduce(self.state, { (currentState, reducer) -> State in
+                    return reducer(currentState, action)
                 })
             }.do(onNext: { [unowned self] (newState) in
                 self.state = newState
             }).distinctUntilChanged()
     }
 
-    public func dispatch<SubStateType: Equatable>(action: Action, on: @escaping (StateType) -> SubStateType) -> Observable<SubStateType> {
-        return self.dispatch(action: action).map { on($0) }
-    }
+//    public func dispatch<SubStateType: Equatable>(action: Action, on: @escaping (State) -> SubStateType) -> Observable<SubStateType> {
+//        return self.dispatch(action: action).map { on($0) }
+//    }
 
 }

RxReduceTests/State/Actions.swift

@@ -17,12 +17,9 @@ struct DecreaseAction: Action {
     let decrement: Int
 }
 
-struct ClearCounterAction: Action {
+struct ClearAction: Action {
 }
 
-struct AddUserAction: Action {
+struct LogUserAction: Action {
     let user: String
 }
-
-struct ClearUsersAction: Action {
-}

RxReduceTests/State/Reducers.swift

@@ -9,13 +9,12 @@
 import Foundation
 import RxReduce
 
-func counterReducer (state: TestState, action: Action) -> TestState {
+func counterReduce (state: TestState, action: Action) -> CounterState {
 
-    var currentState = state
     var currentCounter = 0
 
     // we extract the current counter value from the current state
-    switch currentState.counterState {
+    switch state.counterState {
     case .decreasing(let counter), .increasing(let counter):
         currentCounter = counter
     default:
@@ -25,32 +24,25 @@ func counterReducer (state: TestState, action: Action) -> TestState {
     // according to the action we mutate the counter state
     switch action {
     case let action as IncreaseAction:
-        currentState.counterState = .increasing(currentCounter+action.increment)
-        return currentState
+        return .increasing(currentCounter+action.increment)
     case let action as DecreaseAction:
-        currentState.counterState = .decreasing(currentCounter-action.decrement)
-        return currentState
-    case is ClearCounterAction:
-        currentState.counterState = .empty
-        return currentState
+        return .decreasing(currentCounter-action.decrement)
+    case is ClearAction:
+        return .empty
     default:
-        return currentState
+        return state.counterState
     }
 }
 
-func usersReducer (state: TestState, action: Action) -> TestState {
-
-    var currentState = state
+func userReduce (state: TestState, action: Action) -> UserState {
 
     // according to the action we mutate the users state
     switch action {
-    case let action as AddUserAction:
-        currentState.users.append(action.user)
-        return currentState
-    case is ClearUsersAction:
-        currentState.users.removeAll()
-        return currentState
+    case let action as LogUserAction:
+        return .loggedIn(name: action.user)
+    case is ClearAction:
+        return .loggedOut
     default:
-        return currentState
+        return state.userState
     }
 }

RxReduceTests/State/States.swift

@@ -11,11 +11,16 @@ import RxReduce
 
 struct TestState: Equatable {
     var counterState: CounterState
-    var users: [String]
+    var userState: UserState
 }
 
 enum CounterState: Equatable {
     case empty
     case increasing (Int)
     case decreasing (Int)
 }
+
+enum UserState: Equatable {
+    case loggedIn (name: String)
+    case loggedOut
+}