Compiler having trouble type-checking the view but the types are correct

[ghost]

Hello :)

I have a custom view (TextFieldAlert) that behaves like an alert and participates in presentation like an alert but I can't use the .alert view modifier for it because it's not driven by AlertState. Since it participates in presentation like other presentations, it's part of the Destination enum:

extension MyScene {

   public struct Destination: ReducerProtocol {

      public var body: some ReducerProtocolOf<Self> {
         // other destination Scopes
         
         Scope(
            state: /State.passcodeRequestAlert,
            action: /Action.passcodeRequestAlert
         ) { TextFieldAlert() }
         
         Scope(
            state: /State.emailRequestAlert,
            action: /Action.emailRequestAlert
         ) { TextFieldAlert() }
      }

   }

}

extension MyScene.Destination {

   public enum State: Equatable {
      // other destination states
      case passcodeRequestAlert(TextFieldAlert.State)
      case emailRequestAlert(TextFieldAlert.State)
   }

   public enum Action: Equatable {
      // other destination actions
      case passcodeRequestAlert(TextFieldAlert.Action)
      case emailRequestAlert(TextFieldAlert.Action)
   }

}

MyScene has the expected structure:

public struct MyScene: ReducerProtocol {

   public var body: some ReducerProtocol<State, Action> {
      Reduce { state, action in
         switch action {
            // other action handlers

            case let .passcodeRequestAlert(action):
               // handle action from the passcode request alert
               return .none

            case let .emailRequestAlert(action):
               // handle action from the email request alert
               return .none

            case let .destination(destAction):
               // handle action from other destinations
               return .none
         }
      }
      .ifLet(\.$destination, action: /Action.destination) {
         Destination()
      }
   }

   public struct State: Equatable {
      // other properties      
      @PresentationState public var destination: Destination.State?
   }

   public enum Action: Equatable {
      // other actions
      case passcodeRequestAlert(TextFieldAlert.Action)
      case emailRequestAlert(TextFieldAlert.Action)
      case destination(PresentationAction<Destination.Action>)
   }

}

This all compiles fine. Now, the view. This is what I think I should have:

extension MyScene {

   public struct View: SwiftUI.View {

      private let store: Store<State, Action>
      public init(store: Store<State, Action>) { self.store = store }

      struct ViewState: Equatable {
         // some properties
         init(state: State) {
            // self.property = state.property
         }
      }

      public var body: some SwiftUI.View {
         WithViewStore(store, observe: ViewState.init) { vs in
            ZStack {

               SomeView() // the main body of the view

               IfLetStore(store.scope(
                    state: \.$destination, 
                    action: Action.destination
                )) { store in
                  SwitchStore(store) { state in
                     switch state {
                        case .passcodeRequestAlert:
                           CaseLet(
                              state: /Destination.State.passcodeRequestAlert,
                              action: Destination.Action.passcodeRequestAlert,
                              content: TextFieldAlert.View.init
                           )
                        case .emailRequestAlert:
                           CaseLet(
                              state: /Destination.State.emailRequestAlert,
                              action: Destination.Action.emailRequestAlert,
                              content: TextFieldAlert.View.init
                           )
                        default:
                           EmptyView()
                     }
                  }
               }

            }
            .someViewModifier(vs.someProperty)
         }
      }

   }

}

but the compiler complains that it can't type-check the code in reasonable time so I tried to give it a little help to narrow down the source of the problem, like so:

IfLetStore(store.scope(
   state: \.$destination,
   action: Action.destination
)) { (store: StoreOf<Destination>) in
   SwitchStore(store) { (state: Destination.State) in
      switch state {
         case let .passcodeRequestAlert(destState):
            CaseLet(
               state: { _ in destState },
               action: Destination.Action.passcodeRequestAlert,
               content: TextFieldAlert.View.init
            )
         case .emailRequestAlert:
            EmptyView()
         default:
            EmptyView()
      }
   }
}

This still baffles the compiler. I know the problem is with the CaseLet because commenting them all out and replacing them with EmptyView(), as in

public var body: some SwiftUI.View {
     WithViewStore(store, observe: ViewState.init) { vs in
        ZStack {
    
           SomeView() // the main body of the view
    
           IfLetStore(store.scope(
                state: \.$destination, 
                action: Action.destination
            )) { store in
              SwitchStore(store) { state in
                 switch state {
                    case .passcodeRequestAlert:
                       EmptyView()
                    case .emailRequestAlert:
                       EmptyView()
                    default:
                       EmptyView()
                 }
              }
           }
    
        }
        .someViewModifier(vs.someProperty)
     }
}

compiles fine.

Can anyone please shed some light on what I'm doing wrong? As far as I can tell, all the types are correct.

Many thanks in advance.

[coenttb]

I believe that using CaseLet requires that all such views are CaseLets.

[ghost]

Actually, that's not the case.

[stephencelis]

It used to be the case, and is the case for the initializers that don't take any closure arguments, but the initializer that takes state as an argument is more flexible since you can compile-time switch over it.

[ghost]

Ha, I finally figured out what the problem was. CaseLet's last argument has the label then, not the label content. So, this

IfLetStore(store.scope(state: \.$destination, action: Action.destination)) { store in
   SwitchStore(store) { state in
      switch state {
         case .passcodeRequestAlert:
            CaseLet(
               state: /Destination.State.passcodeRequestAlert,
               action: Destination.Action.passcodeRequestAlert,
               content: TextFieldAlert.View.init
            )
         case .emailRequestAlert:
            CaseLet(
               state: /Destination.State.emailRequestAlert,
               action: Destination.Action.emailRequestAlert,
               content: TextFieldAlert.View.init
            )
         default:
            EmptyView()
      }
   }
}

doesn't compile but this, the correct syntax, naturally does:

IfLetStore(store.scope(state: \.$destination, action: Action.destination)) { store in
   SwitchStore(store) { state in
      switch state {
         case .passcodeRequestAlert:
            CaseLet(
               state: /Destination.State.passcodeRequestAlert,
               action: Destination.Action.passcodeRequestAlert,
               then: TextFieldAlert.View.init
            )
         case .emailRequestAlert:
            CaseLet(
               state: /Destination.State.emailRequestAlert,
               action: Destination.Action.emailRequestAlert,
               then: TextFieldAlert.View.init
            )
         default:
            EmptyView()
      }
   }
}

I wish Xcode/the Swift compiler had better error reporting. I wasted a lot of time and effort on this.

[stephencelis]

Glad you figured it out! While it won't help immediately, we're finding/hoping that the new Observability framework will help us get rid of WithViewStore, IfLetStore, ForEachStore, SwitchStore and CaseLet, all of which can strain the compiler, so hopefully this becomes avoidable in the future.