Using BindingState in a ViewState to observe less in parent view

[Jeehut]

I have a feature with a @BindingState property and an optional @PresentationState property in its State. In the view of this feature, I only care about the @BindingState property and about the non-nil-ness of the @PresentationState property, but not about each change in it. When I try to create a ViewState where only the @BindingState property and a Bool property named presentingChildView exist and try to pass that to the observe: when creating WithViewStore, I get the following error when trying to call .binding in the view:

Cannot convert value of type 'Binding<ParentView.ViewState>' to expected argument type 'Binding<String>'

Now if I change the case binding(BindingAction<State>) to be case binding(BindingAction<ParentView.ViewState>), another error appears to the line of my BindingReducer():

Generic struct 'BindingReducer' requires the types 'ParentFeature.State' and 'ParentView.ViewState' be equivalent

How can I deal with such a situation? How can I prevent my parent from recomputing for all changes of the child but also continue using binding on the parent?

Context: I'm on the prerelease/1.0 branch, commit f2c6e5f, Xcode 13.2 beta 2

Here's some sample code if the above wasn't clear enough:

struct ParentFeature: Reducer {
   struct State: Equatable {
      @BindingState
      var someStruct: SomeStruct = .init()

      @PresentationState
      var childFeature: ChildFeature.State?
   }

   enum Action: Equatable, BindableAction {
      case binding(BindingAction<ParentView.ViewState>) // also tried `case binding(BindingAction<State>)`
      case backFromChildView
      // ...
      case childFeature(action: PresentationAction<ChildFeature.Action>)
   }

   var body: some ReducerOf<Self> {
      BindingReducer()

      Reduce<State, Action> { state, action in
         switch action {
         // ...
         case .backFromChildView:
            // reload data
            return .none
         case .binding, .childFeature:
            return .none
      }
      .ifLet(\.$childFeature, action: /Action.childFeature) {
         ChildFeature()
      }
   }
}

struct ParentView: View {
   let store: StoreOf<ParentFeature>

   struct ViewState: Equatable {
      @BindingState
      var someStruct: SomeStruct
      var presentingChildView: Bool

      init(state: ParentFeature.State) {
         self.someStruct = state.someStruct
         self.presentingChildView = state.childFeature != nil
      }
   }

   var body: some View {
      WithViewStore(self.store, observe: ViewState.init) { viewStore in
         Form {
            Section {
               TextField("Name", text: viewStore.binding(\.$someStruct.name))
               TextField("Details", text: viewStore.binding(\.$someStruct.details))
            }
         }
         .onChange(of: viewStore.presentingChildView) { newValue in
            viewStore.send(.backFromChildView)
         }
      }
   }
}

[stephencelis]

At the moment, @BindingState and ViewState do not play super nicely together, but there are tools that ship with the library, particularly BindingAction.pullback, that make it possible to use @BindingState in a parent domain that uses view state. I will note that we're not super happy with the boilerplate involved (especially for a tool whose purpose is to eliminate boilerplate). We have some experiments to make @BindingState and ViewState play much more nicely together, but we're not 100% ready to ship them yet. Hopefully soon!

[Jeehut]

@stephencelis Thank you for the pointer, I'll test it out. Looking forward to a simplified version in the future, too! 👍