CasePaths for enums containing non-enum state

[technicated]

Hello everyone 👋

I have a question about CasePaths with non-enum nested objects, but first, a little bit of context.

I have developed a TypeScript library that tries to mimic Swift enums, and in this library I am also modeling CasePaths based on what I've learned from Point-Free videos. This library works surprisingly well given what TypeScript has to offer!

Now, for a TypeScript project at work, I am creating API routes that resemble those in Isoword, but the routes are more elaborate and nested since they are REST APIs.

Here are some example routes:

POST /api/certifications  |  create a new blank Certification
GET /api/certifications  |  get a paginated list of all the Certifications
GET /api/certifications/<id>  |  get the details of a specific Certification
GET /api/certifications/<id>/properties  |  get all the properties (real estate) registered inside a Certification 
POST /api/certifications/<id>/properties  |  add a new the property (real estate) to a Certification 
GET /api/certifications/<id>/visure/<protocol>  |  get a specific Visura (a type of document) registered within a Certification

What we have written in TS using my library could be translated in Swift like:

@CasePathable
enum Route {
  case certifications(Certifications)
}

@CasePathable
enum Certifications {
  case getAll(page: Int, perPage: Int) // [2]
  case getOne(certificationUuid: UUID) // [3]
  case properties(certificationUuid: UUID, Properties)
  case register // [1]
  case visure(certificationUuid: UUID, Visure)
}

@CasePathable
enum Properties {
  case addOne(kind: PropertyKind, ...) // [5]
  case getAll // [4]
}

@CasePathable
enum Visure {
  case getOne(protocol: String) // [6]
}

However, I am encountering issues with CasePaths for Properties and Visure routes. Autocompletion only shows results for some cases, and for \.certifications.(properties | visure) it only shows .never.

What am I missing? Am I doing something wrong? Is there a better way to do this? Since my ts-enums library works the same as swift-case-paths, I am encountering the same problem in my codebase.

Thank you everyone for your support!

[stephencelis]

A case path describes extracting and embedding an associated value from/in an enum:

@CasePathable enum Foo { case bar(Int) }

let barPath: CaseKeyPath<Foo, Int> = \.bar
let bar = barPath(42)  // Foo.bar(42)
bar[case: barPath]     // Optional.some(42)

When you chain into a property of a product type (like the tuple of values in certifications), you lose the ability to embed. As a thought exercise let's say we could chain a key path into a case path:

@CasePathable enum Foo { case bar(int: Int, string: String) }

let barPath: CaseKeyPath<Foo, String> = \.bar.string
let bar = barPath("Blob")  // Foo.bar(int: ⁉️, string: "Blob")

There's no way to embed a string in such a theoretical case path because Foo.bar requires an integer to be created, as well.

This has come up before, so for reference: #127

[technicated]

That's obvious in hindsight, so there isn't a way to model what I want to have my cake and eat it too?

One choice I have is push all the parameters at the leaf cases of the leaf enums, but in this way I cannot "print" this enum to a URL request step by step (or even there I am missing something [*]). The other choice is leaving the model as-is and override the API with a concrete Route instance instead of a CaseKeyPath<Route, Value> (which in Isowords is override(route:withResponse:)).

[*] This is because I am doing all this in the TS side of the world, and I have not setup a complete swift-parsing + swift-case-paths + my models project, could I ever discover that this works?