How to handle .binding() actions from ViewAction in a Reducer?

[rkreutz]

Hey everyone,

I was currently migrating one of my apps to prerelease/1.0 (I was on version 0.9.0, so there were a few updates needed 😅) and stumbled on something I thought was kind of weird (I don't think this is related to version 1.0 though).

To give some context I have the following structure (simplified):

// A component which has a toggle in it (this is a simplified version, but on production it would display a view or not given the toggle state)
// Toggle.swift
struct Toggle: Reducer {
    struct State: Equatable {
        @BindingState var isToggled: Bool
    }

    enum Action: BindableAction, Equatable {
        case binding(BindingAction<State>)
    }

    var body: some ReducerOf<Self> {
        BindingReducer()
        Reduce { state, action in
            switch action {
            case .binding(.set(\.$isToggled, true)):
                print("Is Enabled") // I want to change some state when the state has changed, for simplicity I'll just print something
                return .none
            case .binding(.set(\.$isToggled, false)):
                print("Is Disabled") // I want to change some state when the state has changed, for simplicity I'll just print something
                return .none
            default:
                return .none
            }
        }
    }
}

// ToggleView.swift
public struct ToggleView: View {

    // I'm using a ViewState/ViewAction because in production this view has other subviews that can change as well
    // so I only want this view to update when the toggle was changed.
    struct ViewState: Equatable {
        @BindingState var isToggled: Bool
    }

    enum ViewAction: BindableAction, Equatable {
        case binding(BindingAction<ViewState>)

        var domainAction: Toggle.Action {
            switch self {
            case let .binding(action):
                return .binding(action.pullback(\.view))
            }
        }
    }

    let store: StoreOf<Toggle>

    public var body: some View {
        WithViewStore(store, observe: \.view, send: \ViewAction.domainAction) { viewStore in
            SwiftUI.Toggle("Toggle", isOn: viewStore.binding(\.$isToggled))
        }
    }
}

private extension Toggle.State {
    var view: ToggleView.ViewState {
        get { .init(isToggled: isToggled) }
        set { isToggled = newValue.isToggled }
    }
}

So the idea of it is that I have a view with a Toggle in it, which when enabled would show a child-view. To achieve this I have some ViewState so I only update the ToggleView when the toggle itself has changed. Then in the Reducer I have a BindingReducer and a custom Reduce where I also change some state given the new state of the toggle.

The issue is inside this Reduce part, I'm trying to intercept .binding(.set(\.$isToggled, true/false)) but I never get this event, digging a bit more on it, I realised that in var domainAction: Toggle.Action I use action.pullback(\.view) which transforms the event into .binding(.set(\.view.$isToggled, true/false)) (notice the .view path prepended) which makes sense, but since I have var view: ToggleView.ViewState as a private extension in the ToggleView file, the Reducer doesn't have access to it (I'd like to keep it that way tbh so the Reducer is not coupled to the View).

I found a workaround where I could change how I map the domainAction and not use the .pullback() method, like this:

    enum ViewAction: BindableAction, Equatable {
        case binding(BindingAction<ViewState>)

        var domainAction: Toggle.Action {
            switch self {
            case let .binding(.set(\.$isToggled, true)):
                return .binding(.set(\.$isToggled, true))
            case let .binding(.set(\.$isToggled, false)):
                return .binding(.set(\.$isToggled, false))
            case .binding():
                fatalError("Incorrect binding event")
            }
        }
    }

My Reduce starts working as expected, but I get the following message in the console:

2023-04-10 17:39:45.635783+0100 TCATest[36672:11178447] [ComposableArchitecture] A binding action sent from a view store at "TCATest/TCATestApp.swift:68" was not handled. …

  Action:
    ToggleView.ViewAction.binding(.set(_, false))

To fix this, invoke "BindingReducer()" from your feature reducer's "body".

So I was wondering if there is some other way of achieving what I want here without having the message spamming the logs on debug?

Thanks in advance

[ibrahimkteish]

you can listen to BindingState of a ViewState in the reducer like the following:

Reduce { state, action in 
      case .binding(\.view.$isToggled):
      print(state.isToggled)
      return .none
// ....
}

also you need to extend your reducer's Action (Toggle Reducer in your case)

extension Toggle.Action {
  init(action: ToggleView.ViewAction) {
    switch action {
      case let .binding(binding):
        self = .binding(binding.pullback(\.view))
    }
  }
}

finally your ViewStore's init should be
WithViewStore(store, observe: \.view, send: \Toggle.Action.init) { viewStore in ... }

[rkreutz]

Hey, thanks for the reply. Yeah, I'd figured that was one way of doing it, however I feel like this might not be very scalable, since now the Reducer depends on that \.view key path and that's an implementation detail I'd like the Reducer to not know about, for instance you might have multiple views using the same Reducer and each one of them might potentially have their own ViewState, so in the Reducer you would have to do something like:

case .binding(\.view1.$isToggled), .binding(\.view2.$isToggled):
    ....