How to use the ReducerProtocol approach for a feature whose state contains an optional enum?

[ghost]

Hello all,

In our app, we have modelled navigation by having a Route enumerated type (with states for associated types) and a matching NavigationRoute enumerated type. The NavigationRoute type exists simply to extract the name of a Route case, without caring for the associated state, and works as a tag when using the navigation APIs. We do this to avoid having to require States to be Hashable since the tags must be.

extension FooFeature {
   struct State: Equatable {
      var route: Route?
      var navRoute: NavigationRoute? { route?.navRoute }
      // ...
   }
}

extension FooFeature.State {

   enum Route: Equatable {
      case chat(ChatFeature.State)
      case participants(ParticipantsFeature.State)
      // ...

      var navRoute: NavigationRoute {
         switch self {
            case .chat(_):
               return .chat
            case .participants(_):
               return .participants
            // ...
         }
      }
   }

   enum NavigationRoute: Hashable {
      case chat
      case participants
      // ...
   }

}

extension FooFeature {
   enum Action: Equatable {
      case chat(ChatFeature.Action)
      case participants(ParticipantsFeature.Action)
      // ...
   }
}

struct FooFeature: ReducerProtocol {
   var body: some ReducerProtocol<State, Action> {
      Reducer { state, action in
         switch action {
            // ...
         }
      }
     // what goes in here ?
   }
}

It seems to me that this is a combination of the "optional state" and "enum state" ways of modelling state so I thought some combination of the .ifLet() and .ifCaseLet() reducer modifiers would be called for but I couldn't make that work.

Any help would be greatly appreciated. Thanks!

Addendum:

Incidentally, before the ReducerProtocol approach, we created a custom pullback, like so:

public extension Reducer {
    func pullback<GlobalState, GlobalAction, GlobalEnvironment, Route>(
        unwrapping toRoute: WritableKeyPath<GlobalState, Route?>,
        case toRouteCase: CasePath<Route, State>,
        action toLocalAction: CasePath<GlobalAction, Action>,
        environment toLocalEnvironment: @escaping (GlobalEnvironment) -> Environment
    ) -> Reducer<GlobalState, GlobalAction, GlobalEnvironment> {
        .init { globalState, globalAction, globalEnvironment in

            // do we have the correct child action?
            guard
                let localAction = toLocalAction.extract(from: globalAction)
            else { return .none }

            guard
                // is a child actually being presented?
                let route = globalState[keyPath: toRoute],
                // if so, do we have the right child/reducer pair?
                let routeCase = toRouteCase.extract(from: route)
            else { return .none } // if not, don't run the child reducer

            // get the child state
            var localState = routeCase

            // make sure to pass the (possibly updated) child state back to the parent
            defer { globalState[keyPath: toRoute] = toRouteCase.embed(localState) }

            // run the child reducer
            let effects = self.run(
                &localState,
                localAction,
                toLocalEnvironment(globalEnvironment)
            )
            .map(toLocalAction.embed)

            return effects
        }
    }
}

[tgrapperon]

Hey @wtruppel. Because of the "modifier" style approach that was selected, there is no "convenient" way to scope into optional enums right now (wrong, see @stephencelis answer below). One solution is to open the optional, and then open the enum's case using an EmptyReducer as a support:

Reduce { state, action in
  switch action {
    …  
  }
}
.ifLet(\.route, action: /Action.route) {            // Route? -> Route
  EmptyReducer()
    .ifCaseLet(/Route.chat, action: /Action.chat) { // Route -> Route.case
      ChatFeature()
    }
    .ifCaseLet(/Route.participants, action: /Action.participants) {
      ParticipantsFeature()
    }
}

Once this is working, you can try to make it work with your NavigationRoute enum, which I think is accessory to the problem. There is no ordering problem here because the initial ifLet runs all these reducers before the Reduce one.

Another approach that may help is to "coalesce" the nilness of Route? into Route itself by adding a .none case to Route ¹. In this case, you wouldn't need the ifLet(\.route, …).

Footnotes

1. Fun fact, you can conform Route to NilLiteralConvertible, so you can still use nil to create Route.none. But it absolutely isn't worth the hassle! ↩

[ghost]

Ah, my bad. It was a typo but not the one with the Reducer. In my actual code, the state and actions are called participantsList, not participants so when I tried your suggestion, I forgot to update them and the compiler choked. Anyway, your first suggestion works perfectly, including using /Action.self (no back-quotes needed but specifying the type, Action, was needed). One more time, many thanks for all your help.

[stephencelis]

Just to add to @tgrapperon's answer, you can use Scope to avoid the EmptyReducer-ifCaseLet dance:

Reduce { state, action in
  switch action {
    …  
  }
}
.ifLet(\.route, action: /Action.route) {
  Scope(state: /Route.chat, action: /Action.chat) {
    ChatFeature()
  }
  Scope(state: /Route.participants, action: /Action.participants) {
    ParticipantsFeature()
  }
}

While we prefer ifCaseLet when mixed with other logic that can switch the cases, the cases are mutually exclusive inside the ifLet, so it's safe to use Scope and save a layer of indentation and indirection instead.

[stephencelis]

(Though if you aren't pulling back through multiple layers of actions and are using the /.self case path, that might not be possible.)

[ghost]

Hi @stephencelis. Thanks for the extra info. We're not using another layer of actions so the /.self solution worked great.

[tgrapperon]

@stephencelis Indeed, for some reason, I forgot about Scope's CasePaths overloads.
EDIT: And also the /.self and /Action.self overloads.