ReducerProtocol conformance sometimes not detected?!?

[sbeitzel]

I'll start with: I'm probably Doing It Wrong.

Xcode Version 14.0 (14A309), macOS application.

I just switched my app over to try the ReducerProtocol, because that looks so much cleaner. Couldn't wait. And, sure enough, now my code base is smaller, tidier, easier to scan, and I'm very happy. Except.

I have a couple of cases where feature reducers won't compile when I define their var body: some ReducerProtocol instead of func reduce(...), and I'm not at all sure why.

At the top level, my app reducer compiles just fine:

struct RtApp: ReducerProtocol {
    struct State: Equatable {
// precisely 1.35 jillion properties here
    }

  enum Action { ... }

    var body: some ReducerProtocol<State, Action> {
        Scope(state: \State.authCombined, action: /Action.auth) { Auth() }
        Scope(state: \State.selectPopState, action: /Action.selectPopulation) { SelectPopulation() }
        Scope(state: \State.editPopState, action: /Action.editPopulation) { EditPopulation() }
        Scope(state: \State.viewPopState, action: /Action.viewPopulation) { ViewPopulation() }
        Scope(state: \State.relationState, action: /Action.relationship) { Relation() }
        Scope(state: \State.ancestreeState, action: /Action.ancestree) { Ancestree() }
        Scope(state: \State.profileCombined, action: /Action.profile) { Profile() }
    }
}

Farther down, though, I have a couple of features which each have sub-features (the edit & view population, which each open up to edit/view person). All the other features are implemented using the reduce(into... function, but when I try using the body builder implementation for these two, the compiler says, "Nope, you aren't implementing ReducerProtocol." Thus:

struct EditPopulation: ReducerProtocol {
    struct State: Equatable {
// various properties as well as...
                var invitationState: CInv.State {
            get { ... }
            set { ... }
        }
               var editPersonState: EditPerson.State {
            get { ... }
            set { ... }
        }
    }

    enum Action { ... }

   /* Implementing the protocol with the body property makes the compiler claim that the struct isn't actually conforming
       to the ReducerProtocol.
  var body: some ReducerProtocol {
      Reduce { state, action in
          // feature logic goes here
      }

        Scope(state: \.editPersonState, action: /Action.editPerson) { EditPerson() }

        Scope(state: \.invitationState, action: /Action.invitationAction) { CInv() }
  }
*/

// Implementing the reduce function with some extra fluff does satisfy the compiler about conformance
    func reduce(into state: inout State, action: Action) -> Effect<Action, Never> {
        CombineReducers {
          Reduce { state, action in
          // feature logic goes here
          }

        Scope(state: \.editPersonState, action: /Action.editPerson) { EditPerson() }

        Scope(state: \.invitationState, action: /Action.invitationAction) { CInv() }
      }.reduce(into: &state, action: action)
    }
}

So, what am I doing wrong? Please?

[mbrandonw]

If the commented out code is accurate then you are missing the primary associated types on the protocol:

-var body: some ReducerProtocol {
+var body: some ReducerProtocol<State, Action> {

Ideally we would have a way to tell Swift to autocomplete body with placeholders so that people know what they have to do:

var body: some ReducerProtocol<<#State#>, <#Action#>>

...but unfortunately that is not possible.

We also wanted to ship a helper so that you can write the body like this:

var body: some ReducerProtocolOf<Self>

...but that typealias breaks the Xcode editor currently, and so we are holding off until that is fixed.

[sbeitzel]

thank you, that was it! Although I'd provided the generics at the top level, by the time I'd got down to these features, I'd obviously imagined that the types could be inferred.