Dependency Injection Made Composable

Exercises

1. Fix the PrimeTime application so that it works with the new reducer signature we developed in this episode.

2. What are the differences between the reducer we defined in the episode:

   (inout Value, Action, Environment) -> [Effect<Action>]
   

   And this alternative formulation, where Environment has been curried to after Value and Action?

   (inout Value, Action) -> (Environment) -> [Effect<Action>]
   

   Update the ComposableArchitecture module to use this form of Reducer. What impact does it have on behavior and ergonomics?

   Solution

   The architecture now looks like this:

   public typealias Reducer<Value, Action, Environment> = (inout Value, Action) -> (Environment) -> [Effect<Action>]
   
   public func combine<Value, Action, Environment>(
     _ reducers: Reducer<Value, Action, Environment>...
   ) -> Reducer<Value, Action, Environment> {
     return { value, action in
       let effects = reducers.map { $0(&value, action) }
       return { environment in effects.flatMap { $0(environment) } }
     }
   }
   
   public func pullback<LocalValue, GlobalValue, LocalAction, GlobalAction, LocalEnvironment, GlobalEnvironment>(
     _ reducer: @escaping Reducer<LocalValue, LocalAction, LocalEnvironment>,
     value: WritableKeyPath<GlobalValue, LocalValue>,
     action: CasePath<GlobalAction, LocalAction>,
     environment: @escaping (GlobalEnvironment) -> LocalEnvironment
   ) -> Reducer<GlobalValue, GlobalAction, GlobalEnvironment> {
     return { globalValue, globalAction in
       guard let localAction = action.extract(from: globalAction) else { return { _ in [] } }
       let localEffects = reducer(&globalValue[keyPath: value], localAction)
   
       return { globalEnvironment in
         localEffects(environment(globalEnvironment)).map { localEffect in
           localEffect.map(action.embed)
             .eraseToEffect()
         }
       }
     }
   }
   
   public func logging<Value, Action, Environment>(
     _ reducer: @escaping Reducer<Value, Action, Environment>
   ) -> Reducer<Value, Action, Environment> {
     return { value, action in
       let effects = reducer(&value, action)
       let newValue = value
       return { environment in
         [.fireAndForget {
           print("Action: \(action)")
           print("Value:")
           dump(newValue)
           print("---")
           }] + effects(environment)
       }
     }
   }
   
   public final class Store<Value, Action>: ObservableObject {
     private let reducer: Reducer<Value, Action, Any>
     private let environment: Any
     @Published public private(set) var value: Value
     private var viewCancellable: Cancellable?
     private var effectCancellables: Set<AnyCancellable> = []
   
     public init<Environment>(
       initialValue: Value,
       reducer: @escaping Reducer<Value, Action, Environment>,
       environment: Environment
     ) {
       self.reducer = { value, action in
         let effects = reducer(&value, action)
         return { environment in effects(environment as! Environment) }
       }
       self.value = initialValue
       self.environment = environment
     }
   
     public func send(_ action: Action) {
       let effects = self.reducer(&self.value, action)(self.environment)
       effects.forEach { effect in
         var effectCancellable: AnyCancellable?
         var didComplete = false
         effectCancellable = effect.sink(
           receiveCompletion: { [weak self] _ in
             didComplete = true
             guard let effectCancellable = effectCancellable else { return }
             self?.effectCancellables.remove(effectCancellable)
         },
           receiveValue: self.send
         )
         if !didComplete, let effectCancellable = effectCancellable {
           self.effectCancellables.insert(effectCancellable)
         }
       }
     }
   
     public func view<LocalValue, LocalAction>(
       value toLocalValue: @escaping (Value) -> LocalValue,
       action toGlobalAction: @escaping (LocalAction) -> Action
     ) -> Store<LocalValue, LocalAction> {
       let localStore = Store<LocalValue, LocalAction>(
         initialValue: toLocalValue(self.value),
         reducer: { localValue, localAction in
           self.send(toGlobalAction(localAction))
           localValue = toLocalValue(self.value)
           return { _ in [] }
       },
         environment: self.environment
       )
       localStore.viewCancellable = self.$value.sink { [weak localStore] newValue in
         localStore?.value = toLocalValue(newValue)
       }
       return localStore
     }
   }
   

   By delaying the application of an environment to a reducer, we are given stricter guarantees that it can never be used to execute arbitrary side effects that mutate the reducer’s value. And this is because value has in-out semantics, and a reducer must mutate this value before opening the trailing function that has an environment in scope. Overall this formulation of a reducer is a little stricter, but also a little less ergonomic, due to the increased nesting involved.

3. Revert any work left over from the previous exercise.

   Update the logging higher-order reducer to make the caller provide their own printing function instead of using print directly in the implementation. The API for this can allow the caller to get access to the printing function by plucking it out of the environment:

   public func logging<Value, Action, Environment>(
     _ reducer: @escaping Reducer<Value, Action, Environment>,
     logger: @escaping (Environment) -> (String) -> Void
   ) -> Reducer<Value, Action, Environment>
   

   Note that the Swift standard library has a second dump function that prints into a given stream/string rather than the console.

   Solution

   public func logging<Value, Action, Environment>(
     _ reducer: @escaping Reducer<Value, Action, Environment>,
     logger: @escaping (Environment) -> (String) -> Void
   ) -> Reducer<Value, Action, Environment> {
     return { value, action, environment in
       let effects = reducer(&value, action, environment)
       let newValue = value
       return [.fireAndForget {
         let print = logger(environment)
         print("Action: \(action)")
         print("Value:")
         var dumpedValue = ""
         dump(newValue, to: &dumpedValue)
         print(dumpedValue)
         print("---")
         }] + effects
     }
   }
   

4. Erase the environment from the store without resorting to a force cast. The simplest way to achieve this is to remove the Anys:

   • Remove the environment property from the store so that it’s not even possible to force cast it.
   • Replace the reducer property with a Reducer<Value, Action, Void>
   • Update the initializer, send, and view methods accordingly.

   Solution

   The initializer has an environment at the ready, so all we need to do is capture it and pass it along while ignoring the environment inside.

   public final class Store<Value, Action>: ObservableObject {
     private let reducer: Reducer<Value, Action, Void>
     @Published public private(set) var value: Value
     private var viewCancellable: Cancellable?
     private var effectCancellables: Set<AnyCancellable> = []
   
     public init<Environment>(
       initialValue: Value,
       reducer: @escaping Reducer<Value, Action, Environment>,
       environment: Environment
     ) {
       self.reducer = { value, action, _ in
         reducer(&value, action, environment)
       }
       self.value = initialValue
     }
   
     public func send(_ action: Action) {
       let effects = self.reducer(&self.value, action, ())
       effects.forEach { effect in
         var effectCancellable: AnyCancellable?
         var didComplete = false
         effectCancellable = effect.sink(
           receiveCompletion: { [weak self] _ in
             didComplete = true
             guard let effectCancellable = effectCancellable else { return }
             self?.effectCancellables.remove(effectCancellable)
         },
           receiveValue: self.send
         )
         if !didComplete, let effectCancellable = effectCancellable {
           self.effectCancellables.insert(effectCancellable)
         }
       }
     }
   
     public func view<LocalValue, LocalAction>(
       value toLocalValue: @escaping (Value) -> LocalValue,
       action toGlobalAction: @escaping (LocalAction) -> Action
     ) -> Store<LocalValue, LocalAction> {
       let localStore = Store<LocalValue, LocalAction>(
         initialValue: toLocalValue(self.value),
         reducer: { localValue, localAction, _ in
           self.send(toGlobalAction(localAction))
           localValue = toLocalValue(self.value)
           return []
       },
         environment: ()
       )
       localStore.viewCancellable = self.$value.sink { [weak localStore] newValue in
         localStore?.value = toLocalValue(newValue)
       }
       return localStore
     }
   }
   

5. We’ve seen that a reducer with a Void environment is equivalent to a reducer that takes no environment at all. Use this knowledge to further simplify the store by holding onto a function that looks like a reducer, but just doesn’t have the 3rd enviroment argument.

   Solution

   Instead of holding onto a Reducer, we can hold onto a simpler function signature:

   public final class Store<Value, Action>: ObservableObject {
     private let reducer: (inout Value, Action) -> [Effect<Action>]
   

   This simplifies the initializer where the private field is assigned:

   self.reducer = { value, action in
     reducer(&value, action, environment)
   }
   

   And the send method, where this field is invoked:

   let effects = self.reducer(&self.value, action)
   

   The view method can still take a void environment.