Scope a state for a child list item from parent's enum property

[Otbivnoe]

How to properly add a child reducer when a child's state is located in one of an enum case?

extension Trips {
    struct State: Equatable {
        enum Content: Equatable {
            case loading
            case placeholder
            case trips(IdentifiedArrayOf<TripListItem.State>)
        }

        // other properties
        var content: Content
    }
}


extension Trips {
    enum Action {
        // other actions
        case trip(id: TripListItem.State.ID, action: TripListItem.Action)
    }
}

struct Trips: Reducer {
    var body: some Reducer<State, Action> { 
         ....
        // Before (trips as a separated property)
        .forEach(\.trips, action: /Action.trip) {
            TripListItem()
        }
        // After (my ugly attempts to make it works) ❌
        .forEach(/State.Content.trips, action: /Action.trip) {
            TripListItem()
        }
    }
}

[Otbivnoe]

Finally managed to achieve the desired behaviour:

Scope(state: \.content, action: .self) {
    EmptyReducer()
        .ifCaseLet(/State.Content.trips, action: /Action.trip(id:action:)) {
            EmptyReducer()
                .forEach(\.self, action: /.self) {
                    TripListItem()
                }
        }
}

Is it any chance to improve the following code? 🤔

[stephencelis]

@Otbivnoe If the ifCaseLet child reducer's state can't be niled out before receiving an action, you could flatten one more layer using Scope(state: CasePath):

Scope(state: \.content, action: .self) {
    Scope(state: /State.Content.trips, action: .self) {
        EmptyReducer()
            .forEach(\.self, action: /.self) {
                TripListItem()
            }
    }
}

I do also wonder if you think there might be an opportunity to refactor your domain model a bit to clean some of this nesting up.

[p4checo]

Hi @stephencelis, sorry to bump this but I'm facing a similar issue and I guess it's better to ask here than open a new issue 😅

struct Feature: Reducer {
    struct State: Equatable {
        var items: Items.State
    }

    enum Action: Equatable {
        case items(Items.Action)
    }

    var body: some Reducer<State, Action> {
        Scope(state: \.items, action: /Action.items) {
            Scope(/Items.State.foo, action: /Items.Action.foo) {
                EmptyReducer() // <<- awkwardness here 🙈
                    .forEach(\.self, action: /.self) { Foo() } // <<- awkwardness here 🙈
            }
            Scope(/Items.State.bar, action: /Items.Action.bar) {
                EmptyReducer() // <<- awkwardness here 🙈
                    .forEach(\.self, action: /.self) { Bar() } // <<- awkwardness here 🙈
            }
        }

        Reduce { state, action in .none }
    }

    enum Items {
        enum State: Equatable {
            case empty
            case foo(IdentifiedArrayOf<Foo.State>)
            case bar(IdentifiedArrayOf<Bar.State>)
            case noResults(String)
        }

        enum Action: Equatable {
            case empty(Never)
            case foo(Foo.State.ID, Foo.Action)
            case bar(Bar.State.ID, Bar.Action)
            case noResults(Never)
        }
    }
}

I do also wonder if you think there might be an opportunity to refactor your domain model a bit to clean some of this nesting up.

Could you please provide some concrete suggestions about how the domain model could be refactored?

If the nested collection inside a case can't be avoided (ifCaseLet+forEach), would it make sense to improve ergonomics by creating a "standalone" ForEachReducer() (on self), or even better a Scope(forEach:action:))? The latter seems to provide the best ergonomics/clarity:

Scope(state: \.content, action: .self) {
    Scope(state: /State.Content.trips, action: .self) { 
        ForEachReducer { TripListItem() }
  }
}

// or

Scope(state: \.content, action: .self) {
    Scope(forEachState: /State.Content.trips, action: .self) { TripListItem() }
}

Thanks! 🙏🏼