Convenience reducers when actions are binding actions

[atfelix]

Reducer convenience methods

I was experimenting with BindingAction on some screens that only use BindingActions. I wrote some convenience methods that simplify the reducers. Let me know what you think:

extension Reducer
where
  Action == BindingAction<State>
{
  public static var bindingAction: Reducer<State, BindingAction<State>, Environment> {
    Reducer.empty.binding()
  }

  public func binding() -> Self {
    Self { state, action, environment in
      action.set(&state)
      return .none
    }
  }
}

View actions

With this convenience API, we can use BindingAction<State> as the action in the reducer:

struct Section: View {
  struct State {
    var name: String
    var email: String
  }

  let store: Store<State, BindingAction<State>>

  var body: some View {
    WithViewStore(self.store) { viewStore in
      Section {
        TextField(
          "First Name",
          text: viewStore.binding(
            keyPath: \.firstName,
            send: { $0 }
          )
        )
        TextField(
          "Last Name",
          text: viewStore.binding(
            keyPath: \.lastName,
            send: { $0 }
          )
        )
      }
    }
  }
}

The alternative would be to wrap BindingAction<State> inside of an enumeration like so

struct Section: View {
  enum Action {
    case bindingAction(BindingAction<State>)
  }
  // ...
}

Reducer call site

At the call site, I no longer needed to create named reducers. This flow works well when my reducers aren't particularly complicated:

let appReducer: Reducer<AppState, AppAction, AppEnvironment> =
  .combine(
    Reducer.bindingAction
      .pullback(...),
    Reducer.bindingAction
      .pullback(...),
    Reducer.bindingAction
      .pullback(...)
  )

A CasePath alternative

One alternative I considered was to create a generic action that embeds BindingAction like the below block of code and use that for actions, but I preferred the above API and call site.

enum EmbeddedBindingAction<State> {
  case bindingAction(BindingAction<State>)
}