Composable State Management: Higher-Order Reducers

Exercises

1. Create a higher-order reducer with the following signature:

   func filterActions<Value, Action>(_ predicate: @escaping (Action) -> Bool)
     -> (@escaping (inout Value, Action) -> Void)
     -> (inout Value, Action) -> Void {
     fatalError("Unimplemented")
   }
   

   This allows you to transform any reducer into one that only listens to certain actions.

   Solution

   func filterActions<Value, Action>(_ predicate: @escaping (Action) -> Bool)
     -> (@escaping (inout Value, Action) -> Void)
     -> (inout Value, Action) -> Void {
       return { reducer in
         return { value, action in
           if predicate(action) {
             reducer(&value, action)
           }
         }
       }
   }
   

2. Create a higher-order reducer that adds the functionality of undo to any reducer. You can start by providing new types to augment the existing state and actions of a reducer:

   struct UndoState<Value> {
     var value: Value
     var history: [Value]
     var canUndo: Bool { !self.history.isEmpty }
   }
   
   enum UndoAction<Action> {
     case action(Action)
     case undo
   }
   

   And then implement the following function to implement the functionality:

   func undo<Value, Action>(
     _ reducer: @escaping (inout Value, Action) -> Void
   ) -> (inout UndoState<Value>, UndoAction<Action>) -> Void {
     fatalError("Unimplemented")
   }
   

   Solution

   func undo<Value, Action>(
     _ reducer: @escaping (inout Value, Action) -> Void
   ) -> (inout UndoState<Value>, UndoAction<Action>) -> Void {
     return { undoState, undoAction in
       switch undoAction {
       case let .action(action):
         var currentValue = undoState.value
         reducer(&currentValue, action)
         undoState.history.append(currentValue)
       case .undo:
         guard undoState.canUndo else { return }
         undoState.value = undoState.history.removeLast()
       }
     }
   }
   

3. Enhance the undo higher-order reducer so that it limits the size of the undo history.

   Solution

   func undo<Value, Action>(
     _ reducer: @escaping (inout Value, Action) -> Void,
     limit: Int
   ) -> (inout UndoState<Value>, UndoAction<Action>) -> Void {
     return { undoState, undoAction in
       switch undoAction {
       case let .action(action):
         var currentValue = undoState.value
         reducer(&currentValue, action)
         undoState.history.append(currentValue)
         if undoState.history.count > limit {
           undoState.history.removeFirst()
         }
       case .undo:
         guard undoState.canUndo else { return }
         undoState.value = undoState.history.removeLast()
       }
     }
   }
   

4. Enhance the undo higher-order reducer to also allow redoing.

   Solution

   In order to keep track of redoes, the state can be modified to track what’s been undone and whether or not there are things to be redone:

   struct UndoState<Value> {
     var value: Value
     var history: [Value]
     var undone: [Value]
     var canUndo: Bool { !self.history.isEmpty }
     var canRedo: Bool { !self.undone.isEmpty }
   }
   

   Meanwhile, we need a new action to redo:

   enum UndoAction<Action> {
     case action(Action)
     case undo
     case redo
   }
   

   And finally, the higher-order reducer must handle the redo:

   func undo<Value, Action>(
     _ reducer: @escaping (inout Value, Action) -> Void,
     limit: Int
   ) -> (inout UndoState<Value>, UndoAction<Action>) -> Void {
     return { undoState, undoAction in
       switch undoAction {
       case let .action(action):
         var currentValue = undoState.value
         reducer(&currentValue, action)
         undoState.history.append(currentValue)
         undoState.undone = []
         if undoState.history.count > limit {
           undoState.history.removeFirst()
         }
       case .undo:
         guard undoState.canUndo else { return }
         undoState.undone.append(undoState.value)
         undoState.value = undoState.history.removeLast()
       case .redo:
         guard undoState.canRedo else { return }
         undoState.history.append(undoState.value)
         undoState.value = undoState.undone.removeFirst()
       }
     }
   }
   

5. Add undo and redo buttons to the CounterView, and make them undo and redo only the counter actions on that screen.