Fighting the compiler when trying to use a CasePath in a reducer

[wltrup]

Hello :)

I'm struggling to get the code below to compile when trying to use a case path to the Detail state in the reducer pullback.

As written below (and with suitable code for the Detail scene), the code compiles fine but then having to manually create a property to extract the child (detail) state from the route property defeats the purpose of using enums (with states as associated types) for navigation.

When I tried the more natural code that is commented out, with or without the .optional() modifier for the reducer (by the way, it's not clear to me whether I should or shouldn't have it), I got the indicated error messages.

I do understand the messages, in particular, that the two case paths (expected and provided) are of different types. My problem is that I don't know how to provide the correct one, given the set up for the Parent scene state.

Any help or clarification would be greatly appreciated. Many thanks in advance!

import ComposableArchitecture

enum Parent {}

extension Parent {

    struct State: Equatable {

        var route: Route?

        enum Route: Equatable {
            case detail(Detail.State)
        }

    }

}

extension Parent {

    enum Action: Equatable {
        case presentDetail(Bool)
        case detail(Detail.Action)
    }

}

extension Parent {

    static let reducer: Reducer<State, Action, Void> =

    //    Detail.reducer
    //        .optional()
    //        .pullback(
    //            state: /State.Route.detail,
    //            action: /Action.detail,
    //            environment: {}
    //        )
    //// Cannot convert value of type
    ////  'CasePath<Parent.State.Route, Detail.State>' to expected argument type
    //// 'WritableKeyPath<Parent.State, Detail.State?>'

    //    Detail.reducer
    //        .pullback(
    //            state: /State.Route.detail,
    //            action: /Action.detail,
    //            environment: {}
    //        )
    //// Cannot convert value of type
    //// 'CasePath<Parent.State.Route?, Detail.State>' to expected argument type
    //// 'CasePath<Parent.State,        Detail.State>'

        Detail.reducer
            .optional()
            .pullback(
                state: \.detail,
                action: /Action.detail,
                environment: {}
            )

}

extension Parent.State {

    var detail: Detail.State? {
        get { (/Route.detail).extract(from: route) }
        set {
            guard let detailState = newValue else { route = nil; return }
            route = (/Route.detail).embed(detailState)
        }
    }

}

[tgrapperon]

Hello!
I think you're jumping a step too early into the CasePath pullback. In this configuration, you need a pullback to bring you to \.route (a (Writable)KeyPath), and then another one to drill-down inside the enum's. Something like

detail
  .pullback(state: /State.Route.detail, action: /Action.detail, …)
  .optional()
  .pullback(state: \.route, action: /Action.self, …)

If you read from bottom to top, you go through .route, then unwrap, then extract the case. When the "detail" state flows back, it is embedded as Route.detail(state), then wrapped into an optional Route?, and then installed into .route. I haven't checked, but it should hopefully build set up like this.
The .optional() there is related to the optionality of var route: Route?. You could imagine that this Route value would be a non-optional route var route: Route, and you would have a .none case in Route. In this case, you wouldn't need .optional().
I agree this is a little dense, and there are probably ways to improve the syntax, especially when TCA will start to handle navigation in a more formalized way, or when it will allow reducer protocols and allow to write pullbacks in the opposite (or "scoping") direction.

[wltrup]

Hi @tgrapperon. Many thanks for a quick response. What you suggested almost works. :)

extension Parent {

    static let reducer: Reducer<State, Action, Void> =
    Detail.reducer
        .pullback(
            state: /.detail,
            action: /Action.detail,
            environment: {}
        )
        .optional()
        .pullback(
            state: /.route, // Member 'route' in 'Parent.State' produces result of type 'Parent.State.Route?', but context expects 'Parent.State'
            action: /Action.self,
            environment: {}
        )

}

Conceptually, I understand your explanation starting with "If you read from bottom to top..." but I must admit that I just don't grasp how that actually happens in the code. The way I understand it, we start with a reducer (Detail.reducer) operating in the Detail domain and we want to pull it back to operate in the Parent domain. (So, I'm reading from top to bottom, not the other way around.)

At that point, the pullback's state slot expects an argument of type CasePath<Parent.State, Detail.State>, ie, we need a transformation from Detail.State to Parent.State (and back). That, somehow, has to go through the Route so I suppose we need a composition of case paths along the lines of CasePath<Parent.State, Route> x CasePath<Route, Detail.State>, but Parent.State only has an optional Route so we really need something like CasePath<Parent.State, Route?> x CasePath<Route?, Route> x CasePath<Route, Detail.State>.

I don't know how to compose the case paths to achieve that result and then use only one pullback. Alternatively, trying to use two pullbacks with the optional in the middle, as you suggested, still doesn't work, despite making sense to me.

I don't find all of this particularly dense but I do think it's very abstract and obscure.

Anyway, it's late in the night here so I'm going to sleep and won't check this thread again until tomorrow.

[tgrapperon]

I think it works, but the route needs to be a KeyPath (with \.), and you used an ill-formed CasePath (with /.), and the error message is unfortunately not helping much. I think you're getting it, but you made a small typo that hopefully wouldn't be possible if we have KeyPath for enum's cases someday.

Reading/reasoning from top to bottom or the other way is only a matter of preference, as the pullback describes a two-way data-flow: you scope your parent state into some child state, make the child reducer work on this specific state, and embed the result back into the parent. The order with which we write pullbacks with the current version of TCA follows the action's flow and is the same as "the way back" of the data, once the child data is processed by the child reducer and embedded back into the parent state.

Let's forget the enum Route for a moment, and imagine instead that this is a regular struct of a complete "Route" domain. You would have:

struct Route {…}
struct State {
  var route: Route?
}
// and then, in the parent reducer,
Route.reducer
  .optional()
  .pullback(state: \.route, action: Action.route)

If your Route state is now an enum, you would likely pullback each case into its domain's Route.reducer:

extension Route {
  static var reducer: Reducer<Route, …> {
    .combine(
      detailReducer.pullback(/Route.detail, …)
      …
    )
  }
}

If you substitute Route.reducer in the parent's reducer by this expression, you would obtain what I initially suggested. Temporarily opacifying the Route domain is how I reasoned to cook up the pullback sandwich.

If you think from from top to bottom, you have

  Detail.reducer                                            // A Reducer<Detail.State, Detail.Action, _>
    .pullBack(state: /Route.detail, action: /Parent.detail) // A Reducer<Route, Action, _>
    .optional()                                             // A Reducer<Route?, Action, _>
	.pullBack(state: \.route, action: /Action.self)         // A Reducer<State, Action, _>

If you want to make things more clear, you can create an autonomous Route feature. I would even say that it's probably a good idea to slightly uncouple/gather navigation in the Parent's domain.

I hope I made things clearer and not the opposite!

[wltrup]

Ah, yes, it was supposed to be a KeyPath not a CasePath. That's what I get from trying to do these things late at night. 🤦‍♂️

It compiles fine now. Many thanks!