Scoping to struct-wrapped action enums with CaseKeyPath

[skyler-cricut]

We're having trouble refactoring from the closure-based scoping function:

public func scope<ChildState, ChildAction>(
  state toChildState: @escaping (_ state: State) -> ChildState,
  action fromChildAction: @escaping (_ childAction: ChildAction) -> Action
) -> Store<ChildState, ChildAction>

to the KeyPath-based one:

public func scope<ChildState, ChildAction>(
  state: KeyPath<State, ChildState>,
  action: CaseKeyPath<Action, ChildAction>
) -> Store<ChildState, ChildAction>

Our problem is that we have some Action enums that wrap their nested values in structs (we do this using a Macro that gives us something similar to private actions).

For example, we might generate code that looks something like this:

@Reducer
struct Feature {
    struct State {
        var childState = ChildFeature.State()
    }

    @CasePathable
    enum Action {
        case protected(ProtectedContainer)

        @CasePathable
        enum Protected {
            case child(ChildFeature.Action)
        }

        struct ProtectedContainer {
            fileprivate let action: Action.Protected
            fileprivate init(_ action: Action.Protected) {
                self.action = action
            }
        }
    }
}

@Reducer
struct ChildFeature {
    struct State { }
    
    @CasePathable
    enum Action { }
}

If we then create a store like this:

let store: StoreOf<Feature> = .init(initialState: .init(), reducer: { })

We don't know how to scope that store to a Reducer over the child action:

let childStore: StoreOf<ChildFeature> = store.scope(state: \.childState, action: /* What goes here? */)

We've tried several approaches, such as constructing the CaseKeyPath manually, but nothing we have tried so far has worked. Admittedly, we frequently get confused between CaseKeyPath, AnyCasePath, Case<...>, and KeyPath<...>, so I wouldn't be surprised if we've missed something. Any help would be much appreciated!

[oliverfoggin]

Hmm... if your action is indeed filePrivate then I'm not sure there's anything that you could put in there to make that work.

[skyler-cricut]

What is it about fileprivate that makes so it won't work? Suppose that we removed the fileprivate modifier there, do you have an idea that would work then?

The store.scope call could be done in the same file in which ProtectedContainer is defined. We're doing all this with macros anyway.

[mbrandonw]

Hi @skyler-cricut, you essentially need to make your ProtectedContainer into a CasePathable type so that you can continue chaining deeper into these structures. It's a little strange because clearly it's a struct, not an enum, but a struct with a single field is indistinguishable from an enum with a single field, and so it is straightforward to do.

Here are the basics (I also squashed a layer of nesting because it didn't seem important, but if you do need that you can bring it back):

@Reducer
struct Feature {
  struct State {
    var childState = ChildFeature.State()
  }

  @CasePathable
  enum Action {
    case protected(ProtectedContainer)

    struct ProtectedContainer: CasePathable {
      fileprivate let action: ChildFeature.Action
      fileprivate init(_ action: ChildFeature.Action) {
        self.action = action
      }
      struct AllCasePaths {
        fileprivate var child: AnyCasePath<ProtectedContainer, ChildFeature.Action> {
          AnyCasePath(
            embed: { .init($0) },
            extract: { $0.action }
          )
        }
      }
      static let allCasePaths = AllCasePaths()
    }
  }
}

@Reducer
struct ChildFeature {
  struct State { }

  @CasePathable
  enum Action { }
}

@MainActor
func foo() {
  let store: StoreOf<Feature> = .init(initialState: .init(), reducer: { })
  let childStore: StoreOf<ChildFeature> = store.scope(state: \.childState, action: \.protected.child)
}

Note that I even made the var child in AllCasePaths file private that way you can't use it outside this file. Otherwise the parent would be able to use it to extract data from the ProtectedAction even if it could not directly access the inner action.

Also note that this is all work that the @CasePathable macro does for you. We are not really inclined to broaden support for @CasePathable to work on structs with a single field right now, but you could make your own macro to do this if you wanted.

[skyler-cricut]

Thank you!
Yes, that makes sense. We were getting hung up on not being able to apply the @CasePathable macro to our struct, and hadn't considered making it conform manually. I'll give this a try.

Update: This suggestion worked for us!