[ReducerProtocol] Is stateless Reducer a bad idea?

[the-yuyut]

Thank you for having ReducerProtocol. it is really amazing. I found that I would like to use a direct value from a dependency not in the State, like local storage or CoreData, etc.

So I came up with a stateless Reducer, which have @ Dependency to the framework wrapper.

struct SOME_Reducer: ReducerProtocol {
  typealias State = Void

  enum Action: Equatable {
    case onLaunch
    case validateConnection
    case invalidateConnection
    case loadAll
    case update(Value)
    case delegate(Delegate)

    enum Delegate: Equatable {
      case subscriptToValueUpdate(SomeDiff)
      case someThingWentWrong
    }
  }

 @ Dependency(\.THE_FRAMEWORK_WARPPER) var localStorage

  func reduce(into _: inout State, action: Action) -> EffectTask<Action> {
    return SOME_EFFECT
  }
}

With that, I tried to embed this into a parent Reducer, and then I encountered a problem.

Scope(state: ????????????????, action: /Action.some_Action) {
      SOME_Reducer()
    }
}

I found In the previous Reducer, we can use pullback like Scope here, but it also require a KeyPath.

So I use a dummy computed var so that it satisfies the API. Scope(state: \.some_State, ....

var some_State: SOME_Reducer.State {
      get { () }
      nonmutating set {}
    }

But I felt I was doing something wrong.
Maybe it can be

1. Just a dependency, no need to be a Reducer
2. Keep a local state. It can be anything that means nothing. Like last delegate time?

[tgrapperon]

Hey @ytyubox!
Please note that in your case, it is rather simple to implement a custom Stateless reducer:

public struct Stateless<ParentState, ParentAction, Child: ReducerProtocol>: ReducerProtocol
where Child.State == Void  {
  public let action: CasePath<ParentAction, Child.Action>
  public let child: Child
  
  public init<A>(
    action: CasePath<ParentAction, A>,
    @ReducerBuilder<Void, A> child: () -> Child) where A == Child.Action {
    self.action = action
    self.child = child()
  }
  
  public func reduce(into state: inout ParentState, action: ParentAction) -> EffectTask<ParentAction> {
    guard let action = self.action.extract(from: action) else { return .none }
    var void: () = ()
    return child.reduce(into: &void, action: action).map(self.action.embed)
  }
}

That being said, this is rather exotic! Please note that this is equivalent to have a bona-fide child domain that has a Void state, so you can also simply add a var void: () = () to your reducer's state, and scope onto this state:

Scope(state: \.void, action: /Action.someReducer) { SOME_Reducer() }

I don't think that this should be a Dependency or some ReducerProtocol's extension, as you're effectively augmenting the Action's space of the parent reducer. You can maybe achieve the same behavior using other means, but if new Actions are involved, you'll need a Reducer.