Conforming to ReducerProtocol: body vs reduce(into:)

[RandomActsOfCode]

In the reducer protocol migration guide it is shown that leaf node reducers should conform to ReducerProtocol by implementing reduce(into:) whereas non-leaf node reducers should conform by providing a body.

Would there be any downside to always using the result builder approach even for leaf-node features? A leaf node reducer would just contain a single Reduce block within its body, which would result in the body having a type of Reduce<State, Action>. The overhead of doing this appears to be minimal, and it would allow for easier future extensions if / when other reducers need to be combined.

[mbrandonw]

Hi @RandomActsOfCode, nope no real downside! If that's the style that you/your team prefer, then definitely go for it!

There's only one small caveat, and it's something that even came up recently. Using Reduce { ... } in a body can give the Swift compiler troubles when it comes to autocomplete and warnings. So, just supply the generics if you go that route, Reduce<State, Action> { ... }, and the compiler should be able to do a better job. Hopefully this gets fixed in Swift someday in the future.

[tgrapperon]

Just to mention that Reduce {} usually works fine when it is the only reducer in body. You may only need to specify the generics when stacking more reducers, link BindingReducer for example.

[tgrapperon]

Hey @RandomActsOfCode! I'm personally always using body. There is no real penalty in optimized builds, and it makes it easier to iterate with your feature.
I see reduce mostly as a bridge between this declarative approach and the former one.

[RandomActsOfCode]

@tgrapperon @mbrandonw thank you both for confirming 🚀. Looking forward to the migration!

[rcarver]

I've been using this pattern for new features. I like keeping the core reducer and composed reducers separate,

Or, it's easy to modify into the optimal version – by either removing 'core', or renaming 'core' to 'reduce' and removing 'body'

public var body: some ReducerProtocol<State, Action> {
  Reduce(self.core)
}
func core(into state: inout State, action: Action) -> EffectTask<Action> {
  switch action {
    ...
  }
}