Reconsider deprecation of .binding(action:)

[lukeredpath]

When BindableAction was introduced, the overload of .binding that takes an explicit extract function was deprecated. I think there are still valid use cases for this overload, specifically in situations where you might need to be able to handle multiple different binding actions over different sub-state within the same reducer.

For instance, imagine a form that has some dynamic section which can change depending on some other property of the form state - maybe you select from a range of values in one section of the form and depending on your selection, a different sub-section of the form is shown or hidden.

Each of these sub-sections have their own state which in this example is driven entirely by bindable state:

struct FormState {
  var subsectionState: SubsectionState

  enum SubsectionState {
    case one(SectionOneState)
    case two(SectionTwoState)
  }
}

struct SectionOneState {
  @BindableState
  var someValue: String
}

struct SectionTwoState {
  @BindableState
  var someOtherValue: String
}

What I'd ideally like to do is have a single FormAction with a case for each binding action:

enum FormAction {
  case sectionOne(BindingAction<SectionOneState>)
  case sectionTwo(BindingAction<SectionTwoState>)
}

I could then define a reducer for each section as:

let sectionOneReducer = Reducer<SectionOneState, FormAction, Void>
  .empty.binding(action: /FormAction.sectionOne)

let sectionTwoReducer = Reducer<SectionTwoState, FormAction, Void>
  .empty.binding(action: /FormAction.sectionTwo)

And a reducer for the entire subsection state as:

let subsectionReducer = Reducer<SubsectionState, FormAction, Void>
  .combine(
    sectionOneReducer.pullback(
      state: /SubsectionState.sectionOne, 
      action: /.self, 
      environment: { $0 }
    ),
    sectionTwoReducer.pullback(
      state: /SubsectionState.sectionTwo, 
      action: /.self, 
      environment: { $0 }
    )
  )

Because binding(action:) is deprecated, I would instead need to create a separate sub-action enum for each section with a single binding case that I could conform to BindableAction which adds extra boilerplate and makes the pullbacks more complicated than they need to be.

Would it be possible to "undeprecate" this action?

[iampatbrown]

Hey @lukeredpath,

I've had situations similar to this where I've wanted to just use BindingAction as the action instead of a BindableAction

I'd normally introduce a few helpers:

enum BindableActionOf<State>: BindableAction { case binding(BindingAction<State>) }

extension Reducer {
  public static func binding<LocalState>(
    state toLocalState: CasePath<State, LocalState>,
    action toLocalAction: CasePath<Action, BindingAction<LocalState>>
  ) -> Self {
    let reducer = Reducer<LocalState, BindableActionOf<LocalState>, Void>.empty.binding()
    return Reducer<LocalState, BindingAction<LocalState>, Void> { state, action, _ in
      _ = reducer.run(&state, .binding(action), ())
      return .none
    }
    .pullback(state: toLocalState, action: toLocalAction, environment: { _ in })
  }

  public func binding<LocalState>(
    state toLocalState: CasePath<State, LocalState>,
    action toLocalAction: CasePath<Action, BindingAction<LocalState>>
  ) -> Self {
    self.combined(with: .binding(state: toLocalState, action: toLocalAction))
  }
}

extension ViewStore {
  public func binding<Value: Equatable>(
    _ keyPath: WritableKeyPath<State, BindableState<Value>>
  ) -> Binding<Value> where Action == BindingAction<State> {
    self.binding(get: { $0[keyPath: keyPath].wrappedValue }, send: { .set(keyPath, $0) })
  }
}

BindableActionOf is only to get around bindingAction.set being internal.

Your example could then be something like this:

let subsectionReducer = Reducer<SubsectionState, FormAction, Void>.combine(
  .binding(state: /SubsectionState.one, action: /FormAction.one),
  .binding(state: /SubsectionState.two, action: /FormAction.two)
)

Because binding(action:) is deprecated, I would instead need to create a separate sub-action enum for each section with a single binding case that I could conform to BindableAction

This is what I end up doing more often though. If .binding(action:) was reintroduced, I'd probably still use the helpers to reduce some boilerplate.

[lukeredpath]

@iampatbrown sorry for not replying sooner, I just got around to trying this out and its removed a lot of boilerplate which is great.

Would you be willing to share these helpers in a gist with a license attached to them so they can be used in a commercial project please?

[iampatbrown]

No worries @lukeredpath

You're fine to use these helpers. I can create a gist tomorrow if you'd like.

[lukeredpath]

Thank you, if you don't mind as it gives me a more durable URL that I can reference for credit in our codebase.

[iampatbrown]

@lukeredpath iampatbrown/Reducer+BindingHelpers.swift