Observing enums seems to not work as in the examples

[gkaimakas]

Hey!

I'm trying to use the observation-beta branch to play around with enums and all the other tools introduced there.

I have created a simple feature like the following

@Reducer
struct AFeature {
    var body: some ReducerOf<Self> {
        Reduce(core)
    }
    
    init() {}
    
    func core(into state: inout State, action: Action) -> Effect<Action> {
        return .none
    }
}

extension AFeature {
    @ObservableState
    public struct State: Equatable {
        init() {}
    }
    
    public enum Action {
        case onAppear
    }
}

and i'm trying to incorporate AFeature to a root feature:

@Reducer
struct Root {
    
    var body: some ReducerOf<Self> {
        Reduce(core)
            .ifLet(\.one, action: \.one) {
                AFeature()
            }
    }
    
    init() {}
    
    func core(into state: inout State, action: Action) -> Effect<Action> {
        return .none
    }
}

extension Root {
    @ObservableState
    enum State: Equatable {
        case one(AFeature.State)
        case two(AFeature.State)
    }
    
    @CasePathable
    enum Action {
        case one(AFeature.Action)
        case two(AFeature.Action)
    }
}

The thing is that the ifLet reducer does not seem to work as in the examples since it cannot find a keyPath for .one.

Key path cannot refer to static member 'one'

Furthermore in the examples @CasePathable isn't required to get things working but when actually using the observation-beta i have to use it.

[mbrandonw]

Hi @gkaimakas, there are two things you need to do. First, you cannot put State and Action in an extension if you want the @Reducer protocol to do all of its magic since it can't see those types. In particular, it adds @CasePathable to the state enum in addition to the action enum.

So, you can either move those types back into Root to get all the benefits of @Reducer, or you need to explicitly mark State with @CasePathable:

@CasePathable
enum State {
  …
}

And second, you don't want to use the ifLet operator. That's just for unwrapping optional state. You want to use the ifCaseLet operator, which is for unwrapping a case of any enum, not just optionals:

Reduce(core)
  .ifCaseLet(\.one, action: \.one) {
    AFeature()
  }

With that it should work.

[gkaimakas]

thank you @mbrandonw !