How @BindingState works?

[Muhammed9991]

Just trying to get my head around how @BindingState works. In the example below, when the action isUsefulButtonTapped is sent to the reducer. If I initially set isUseful to nil every time isUsefulButtonTapped action is sent to the reducer. Will the binding to isUseful be nil until its later changed to false when all state changes have completed? Or is the final state change the only one observed

struct SomeFeature: Reducer {
    struct State: Equatable {
        @BindingState var isUseful: Bool?
    }
    
    enum Action: Equatable, BindableAction {
        case binding(BindingAction<State>)
        case isUsefulButtonTapped
    }
    
    var body: some ReducerOf<Self> {
        BindingReducer()
        Reduce { state, action in
            switch action {
            
            case .isUsefulButtonTapped:
                state.isUseful = nil // Initial state
                
                // Some action

                state.isUseful = true
                return .none
                
            case .binding:
                return .none
            }
        }
        
    }
}

[mbrandonw]

Hi @Muhammed9991, can you explain what you expect to happen from doing something like this:

case . isUsefulButtonTapped:
  state.isUseful = nil
  state.isUseful = true

Do you expect the view store to emit 2 times for each of these changes?

That is not how it works. A function with an inout parameter cannot observe every change made inside the function. It can only observe the final change. Also, the reduce method is completely synchronous and nothing async can be done inside (that is what effects are for). So there doesn't seem to be a reason to observe each change on the inside.

But if you are talking about something else then can you please provide more information?

[Muhammed9991]

I expected that to be the case but just wanted to confirm. I was having a chat with another developer and they suggested it would emit two times. I think the confusion happened when we were using _.printChanges() in the example below:

struct SomeFeature: Reducer {
    struct State: Equatable {
        @BindingState var isUseful: Bool?
    }
    
    enum Action: Equatable, BindableAction {
        case binding(BindingAction<State>)
        case isUsefulButtonTapped
        case anotherAction
    }
    
    var body: some ReducerOf<Self> {
        BindingReducer()
        Reduce { state, action in
            switch action {
            
            case .isUsefulButtonTapped:
                state.isUseful = nil // Initial state
                // Some action
                return .send(.anotherAction)
                
            case .anotherAction:
                state.isUseful = true
                return .none
                
                
            case .binding:
                return .none
            }
        }
        
    }
}

In the example in the question once the isUseful param was set to true. Any subsequent calls to isUsefulButtonTapped was showing as no state was changing, when using _.printChanges() but in the example above. The state was changing from nil to true but only the true was being observed. I think the idea was that when we send an action we wanted the state to be "reset", which could be passed to the view, then some computations happened which would result in state.isUseful to be true again.