Handling a destination enum with varying types of navigations

[oskarek]

In the new navigation tools for UIKit, is there a way to exhaustively switch on a enum destination, and provide a navigation destination for each case, where some of the cases should be pushed and some should be presented?

A theoretical syntax that would accomplish this would look something like this:

navigationDestination(item: $model.destination) { destination in
  switch destination {
  case childA(let model):
     .present(ChildAViewController(model: model))
  case childB(let model):
     .push(ChildBViewController(model: model))
  case childC(let model):
     .present(ChildCViewController(model: model))
  }
}

which would be possible if there was a version of navigationDestination which took a closure that, instead of just returning a view controller, it returned a type which also decided how to present it. Something like:

enum NavigationDestination {
  case present(UIViewController)
  case push(UIViewController)
}

But maybe there is already a way to accomplish this with the current tools?

[mbrandonw]

Hi @oskarek, right now our tools are focused on building the simplest and most extensible experience for driving navigation from state, while trying to stay true to UIKit's and SwiftUI's APIs. The code you have sketched is something that could be built on top of our tools, and maybe some day we will provide a tool like that, but we want to take is slow for the time being.

To achieve a version of this in the tools we have today, you would do this:

@Observable
class FeatureModel {
  var destination: Destination?

  @CasePathable
  enum Destination {
    case childA(ChildAModel)
    case childB(ChildAModel)
    case childC(ChildAModel)
  }
}

…

present(item: $model.destination.childA) { model in 
  ChildAViewController(model: model)
}
navigationDestination(item: $model.destination.childB) { model in 
  ChildBViewController(model: model)
}
present(item: $model.destination.childC) { model in 
  ChildCViewController(model: model)
}

This of course isn't exhaustive, but it gets the job done for the most part.

[oskarek]

Thanks for the response 🙏

our tools are focused on building the simplest and most extensible experience for driving navigation from state, while trying to stay true to UIKit's and SwiftUI's APIs

I would argue that having the version of navigationDestination that I sketched out would be a simpler API since it could replace both present and the current navigationDestination, and unify those two concepts under a single method. But maybe you don't agree! And perhaps you find it too different from the standard UIKit presentation methods. And I certainly get it if that's the case.

The code you have sketched is something that could be built on top of our tools

That sounds promising. I tried to do that actually, but I don't know how to make use of the currently available methods to create this version that I want, which is why I started this thread. If this could be achieved by utilizing what already exists, then that would be great! Could you guide me on how to do that? Just approximately what that would look like? That would be very helpful 🙏