OptionalScope idea 💡

[sergdort]

Hi, I'm converting some of our reducers to use ReducerProtocol and I really love Scope reducer for child states.

I'm wondering if there is a plan to have (or there is already way of doing it) something similar for optional child states?
Because I'd prefer something similar to Scope rather than combination of Reduce {}.ifLet(). In fact I've implemented it in our codebase like this

struct OptionalScope<ParentState, ParentAction, Child: ReducerProtocol>: ReducerProtocol {
    public let toChildState: WritableKeyPath<ParentState, Child.State?>
    public let toChildAction: CasePath<ParentAction, Child.Action>
    public let child: Child
    
    @usableFromInline
    init(
      toChildState: WritableKeyPath<ParentState, Child.State?>,
      toChildAction: CasePath<ParentAction, Child.Action>,
      child: Child
    ) {
      self.toChildState = toChildState
      self.toChildAction = toChildAction
      self.child = child
    }
    
    @inlinable
    public init(
      state toChildState: WritableKeyPath<ParentState, Child.State?>,
      action toChildAction: CasePath<ParentAction, Child.Action>,
      @ReducerBuilderOf<Child> _ child: () -> Child
    ) {
      self.init(
        toChildState: toChildState,
        toChildAction: toChildAction,
        child: child()
      )
    }
    
    @inlinable
    public func reduce(into state: inout ParentState, action: ParentAction) -> EffectTask<ParentAction> {
        guard let childAction = self.toChildAction.extract(from: action)
        else { return .none }
        guard state[keyPath: self.toChildState] != nil else {
          // TODO: Log error
          return .none
        }
        return self.child.reduce(into: &state[keyPath: self.toChildState]!, action: childAction)
          .map(self.toChildAction.embed)
    }
}

[stephencelis]

@sergdort We specifically push folks towards ifLet, ifCaseLet, and forEach over top-level equivalents (IfLetReducer, IfCaseLetReducer, ForEachReducer) because they help avoid programmer errors around reducer ordering, where a parent reducer may intercept a child action and nil out child state before the child reducer can handle the action:

struct Parent: ReducerProtocol {
  // ...
  Reduce { state, action in
    switch action {
    case .child(.dismiss):
      state.child = nil
    // ...
    }
  }
  OptionalScope(state: \.child, action: /Action.child) {
    Child()
  }
}

struct Child: ReducerProtocol {
  // ...
  func reduce(into state: inout State, action: Action) -> EffectTask<Action> {
    switch action {
    case .dismiss:
      // 😢 Analytics event is never tracked!
      return self.analytics.track(.dimissed)
    // ...
    }
  }
}

ifLet,ifCaseLet, and forEach all enforce running the child domain before the parent and help avoid this bug, and they document this.

That said, we do provide a single escape hatch out there for scoping to a specific case as a Scope overload, which we only recommend using in a reducer that "switches" over mutually exclusive cases and does not change or nil out the case (note the warning in the documentation).

This helper technically lets you achieve more or less the same as your helper above:

Scope(state: /.some, action: /Child.action) {
  Child()
}

However we do not recommend using such a helper outside the mutually exclusive usage I mention earlier, since it makes it easier to re-introduce the bugs our other helpers were designed to avoid.

[sergdort]

Thanks @stephencelis for such a detailed explanation!