Dissmiss multiple views at once

[2farellano]

Hello there, thanks for all the work you guys are doing. currently we're exploring TCA and we faced a situation where we have 3 screens A -> B -> C and from C we need to return to A. each screen has its own state and reducer with the appropriate pullback so A can listen events on B and B on C... however in the Implementation I was able to do when I try to dismiss everything ( from C all the way back to A ) I got a

"BAction.showingC" was received by an optional reducer when its state was "nil". This is generally considered an application logic error, and can happen for a few reasons:

This is because B for some reason was trying to update the state when A set State to nil.

Here is the sample code:

struct A: View {
    
    let store: Store<AppState, AppAction> = Store(
        initialState: AppState(),
        reducer: aReducer,
        environment: Void()
    )
    
    var body: some View {
        WithViewStore(store) { viewStore in
            Button("Show B") {
                viewStore.send(AppAction.showB)
            }
            .sheet(
                isPresented: viewStore.binding(
                    get: { $0.bState != nil},
                    send: AppAction.showingB),
                content: {
                    IfLetStore(
                        store.scope(state: \.bState, action: AppAction.bAction),
                        then: B.init(store:)
                    )
                }
            )
        }
    }
}

struct B: View {
    
    let store: Store<BState, BAction>
    
    var body: some View {
        WithViewStore(store) { viewStore in
            Button("Dismiss B") {
                viewStore.send(BAction.dismissB)
            }
            Button("Show C") {
                viewStore.send(BAction.showC)
            }
            .fullScreenCover(
                isPresented: viewStore.binding(
                    get: { $0.cState != nil},
                    send: BAction.showingC),
                content: {
                    IfLetStore(
                        store.scope(state: \.cState, action: BAction.cAction),
                        then: C.init(store:)
                    )
                }
            )
        }
    }
}

struct C: View {
    
    let store: Store<CState, CAction>
    
    var body: some View {
        WithViewStore(store) { viewStore in
            Button("Dismiss C") {
                viewStore.send(CAction.dismissC)
            }
            Button("Dismiss everything") {
                viewStore.send(CAction.dismissEverything)
            }
        }
    }
}


struct AppState: Equatable {
    var bState: BState? = nil
}

enum AppAction: Equatable {
    
    case showingB(Bool)
    case showB
    
    case bAction(BAction)
}

struct BState: Equatable {
    var cState: CState? = nil
}

enum BAction: Equatable {
    case showC
    
    case showingC(Bool)
    case dismissB
    
    case cAction(CAction)
}

struct CState: Equatable {
    
}

enum CAction: Equatable {
    case dismissEverything
    case dismissC
}

let cReducer: Reducer<CState, CAction, Void> = .init { (state, action, _) -> Effect<CAction, Never> in
    switch action {
    case .dismissEverything:
        return .none
    default:
        break
    }
    return .none
}

let bReducer: Reducer<BState, BAction, Void> = .combine(
    cReducer.optional().pullback(
        state: \BState.cState,
        action: /BAction.cAction,
        environment: {$0}),
    .init({ (state, action, _) -> Effect<BAction, Never> in
        switch action {
        case .showC:
            state.cState = CState()
        case .cAction(.dismissC):
             state.cState = nil
            return .none
        case .cAction(.dismissEverything):
            state.cState = nil
            return Effect(value: BAction.dismissB)
                .eraseToEffect()
        case let .showingC(isShowing):
            print("isShowing: \(isShowing)")
        default:
            break
        }
        return .none
    })
)

let aReducer: Reducer<AppState, AppAction, Void> = .combine(
    bReducer
        .optional()
        .pullback(state: \AppState.bState,
                  action: /AppAction.bAction,
                  environment: { $0 }),
    .init({ (state, action, _) -> Effect<AppAction, Never> in
        switch action {
        case .showB:
            state.bState = BState()
        case .showingB(false):
            state.bState = nil
        case .bAction(.dismissB):
            state.bState = nil
            break
        default:
            break
        }
        return .none
    })
)

NOTE: When going back one by one everything works fine. ( A -> B -> C -> B -> A )

issue.mov

NOTE 2:

Adding a delay of 0.1 seconds makes the implementation above to work as expected however I'll prefer not to rely on an arbitrary delay since the problem might still there.

case .cAction(.dismissEverything):
            state.cState = nil
            return Effect(value: BAction.dismissB)
                .delay(for: 0.1, scheduler: DispatchQueue.main.eraseToAnyScheduler())
                .eraseToEffect()

Any ideas how can I implement that functionality?