Add a protocol for subscripting?

[finestructure]

There's a bit of an asymmetry when it comes to using CasePaths vs structs that's been bothering me to the point where I can never quite remember the syntax 😅.

Here's what I mean (using type definitions from the README). We read and write via keypath subscripts as follows:

user[keyPath: \User.id] = 42
user[keyPath: \User.id] // 42

yet the same for CasePaths looks like this:

let authentication = (/Authentication.authenticated).embed("cafebeef")
(/Authentication.authenticated).extract(from: authentication) // Optional("cafebeef")

It would make more sense to me to be able to do the following:

var auth = Authentication.unauthenticated
auth[casePath: /Authentication.unauthenticated]    // ()
auth[casePath: /Authentication.authenticated]      // nil
auth = .authenticated(accessToken: "foo")
auth[casePath: /Authentication.authenticated]      // "foo"
auth[casePath: /Authentication.authenticated] = "bar"
auth[casePath: /Authentication.authenticated]      // "bar"
auth[casePath: /Authentication.unauthenticated]    // nil

I've added this via a protocol CasePathed (or maybe CasePathSubscripted, CasePathSubscriptable?) that can be adopted by enums:

protocol CasePathed {
    subscript<Value>(casePath casePath: CasePath<Self, Value>) -> Value? { get set }
}

extension CasePathed {
    subscript<Value>(casePath casePath: CasePath<Self, Value>) -> Value? {
        get {
            return casePath.extract(from: self)
        }
        set {
            guard let newValue else { return }
            self = casePath.embed(newValue)
        }
    }
}

and then simply

enum Authentication: CasePathed {
  case authenticated(accessToken: String)
  case unauthenticated
}

I'm sure you've considered this. Is this a bad idea? Not worth it due to having to mark up your enums?

[tgrapperon]

Hey Sven! Without weighting on the PR Discussion itself, you don't need the Root generic in your protocol and you can replace all occurrences with Self to make the warning go away:

protocol CasePathed {
  subscript<Value>(casePath casePath: CasePath<Self, Value>) -> Value? { get set }
}

extension CasePathed {
  subscript<Value>(casePath casePath: CasePath<Self, Value>) -> Value? {
    get {
      return casePath.extract(from: self)
    }
    set {
      guard let newValue else { return }
      self = casePath.embed(newValue)
    }
  }
}

[finestructure]

Ah great, that does the trick indeed! I had tried something like that but must have messed it up in other ways :D

[finestructure]

I've updated the original post. Thanks Thomas!