Is it possible for an enum to generate an enumeration of the *names* of its cases?

[wltrup]

Hello :)

When trying to perform navigation using TCA and an optional enum for the routes, as in

struct State {
   var route: Route?
}

enum Route {
   case sceneA(SceneA.State)
   case sceneB(SceneB.State)
   case sceneC(SceneC.State)
   case sceneD(SceneD.State)
}

I've found useful and, sometimes, even necessary, to have a second enumeration mirroring Route, but with no associated types, and CaseIterable. I call it RouteKey:

enum RouteKey: CaseIterable {
   case sceneA
   case sceneB
   case sceneC
   case sceneD
}

Route then has a computed property that returns the key associated with a given route:

extension Route {
   var key: RouteKey {
      switch self {
         case .sceneA: return .sceneA
         case .sceneB: return .sceneB
         case .sceneC: return .sceneC
         case .sceneD: return .sceneD
      }
   }
}

This has been useful because sometimes I don't care about the child state but only that I am navigating to a specific route. Of course, I can always use if case let .sceneC(_) = state.route or case .sceneD(_): (in a switch statement) but in both cases I have to make explicit which route case I'm dealing with. With the route key and the fact that it is CaseIterable I can perform "generic" operations that don't care about the specific route they're acting on.

But it is tedious to create and maintain this second enumeration, even though the compiler is very helpful.

So, is it possible to auto-generate a CaseIterable enumeration of the Route's case names?

Come to think of it, I think it would be useful also to have a way to extract the type of the associated value of each case of Route. Combined with CasePath, we'd be able to go back and forth between RouteKey values and CasePath instances.

Of course, none of this is specific to the Route enumeration. The idea is for any enumeration to automatically generate its case names and the types of their associated data.

Is any of this possible without having to change the language?

Many thanks!

[tgrapperon]

Hello (again)!
To my knowledge, this is not possible with the current version of Swift. I'm aware that @mbrandonw and @stephencelis are participating in the elaboration of a proposal to bring CasePath functionalities into Swift (and interoperate with regular KeyPaths, although I don't know if they will be a subclass of KeyPath or of some lower type).
With these built-in CasePaths, we should be able to match cases by simply trying to extract, so they should fulfill the role of your CaseIterable enum.

I don't know if there is a direct need for them to form a kind of CasePathIterable construct but I'm aware that there are experiments in this direction for regular KeyPaths, so it is possible the CasePathIterable aspect will be deferred to a future and more universal proposal. I guess we'll see how the proposal goes.

So, with the current state of Swift, I think your best luck is with code generation. The new version of Xcode allows build-step plugins, so it is likely that you can make this thing work even when working with packages.

[wltrup]

Hello (again)! :)

Yeah, I didn't think it would be possible at the moment but wanted to hear other people confirm it, just in case.

Thanks again for your replies to my posts.