Question about generic CasePath value

[ferologics]

I'm playing around with following code:

struct FooState {}
struct BarState {}
struct BazState {}

enum State {
  case foo(FooState), bar(BarState), baz(BazState)
}

enum StateType: String {
  case foo, bar, baz
}

extension StateType {
  func decodeType<V>() -> CasePath<State, V> {
    switch self {
    case .foo: return (/State.foo)
    case .bar: return (/State.bar)
    case .baz: return (/State.baz)
    }
  }
}

But getting an error Cannot convert return expression of type '(State) -> FooState?' to return type 'CasePath<State, V>'. I was under the impression that the / operator produces a valid CasePath<Root, Value>.

GenericCasePathValue-Xcode-13.2.zip

---

Updating decodeType() implementation to following:

extension StateType {
  func decodeType<V>() -> CasePath<State, V> {
    switch self {
    case .foo:
      let a = /State.foo
      return a
    case .bar:
      let a = /State.bar
      return a
    case .baz:
      let a = /State.baz
      return a
    }
  }
}

Produces Cannot convert return expression of type 'CasePath<State, FooState>' to return type 'CasePath<State, V>' error. Maybe this isn't possible at the compiler lever 🤷

[iampatbrown]

How do you plan on using func decodeType()?

[ferologics]

I'm trying to generalize some repetitive code from a decoding initializer:

switch type {
case .foo:
  let content = try decoder.decode(FooState.self, from: data)
  self = .foo(content)
case .bar:
  let content = try decoder.decode(BarState.self, from: data)
  self = .bar(content)
case .baz:
  let content = try decoder.decode(BazState.self, from: data)
  self = .baz(content)
}

[ferologics]

I think it'll require some use of Decodable instead relying on generics, but didn't quite crack the puzzle yet:

extension StateType {
  func decodeType() -> Decodable.Type {
    switch self {
    case .foo: return (/State.foo).valueType
    case .bar: return (/State.bar).valueType
    case .baz: return (/State.baz).valueType
    }
  }
}

extension CasePath where Value: Decodable {
  var valueType: Decodable.Type { Value.self }
}

let foo = StateType(rawValue: "foo")!
let data = "{}".data(using: .utf8)!
let decodeType = foo.decodeType()
decodeType.init(from: decoder) // works but not exactly what I need
let decoded = try JSONDecoder().decode(decodeType, from: data) // <--- Error 🛑

Getting Cannot convert value of type 'Decodable.Type' to expected argument type 'T.Type' and Generic parameter 'T' could not be inferred. Getting closer 🤞 maybe it requires some boxing 🤔

[iampatbrown]

Is the StateType required? or can you just use the State case path directly?

extension CasePath {
  var valueType: Value.Type { Value.self }
}
let data = "{}".data(using: .utf8)!
let decoded = try! JSONDecoder().decode((/State.foo).valueType, from: data)

[ferologics]

At the moment it's required to know which state Value to decode. But it feels a bit redundant to have to duplicate the cases through it.

[ferologics]

Turns out I was trying to over-engineer a bit. CasePaths nor Swift generics are needed for this to work:

public enum State: Decodable {
  case foo(FooState), bar(BarState), baz(BazState)

  enum `Type`: String, Decodable {
    case foo, bar, baz

    enum CodingKeys: CodingKey {
      case type
    }
  }

  public init(from decoder: Decoder) throws {
    let typeContainer = try decoder.container(keyedBy: `Type`.CodingKeys.self)
    let type = try typeContainer.decode(`Type`.self, forKey: .type)
    switch type {
    case .foo: self = .foo(try FooState(from: decoder))
    case .bar: self = .bar(try BarState(from: decoder))
    case .baz: self = .baz(try BazState(from: decoder))
    }
  }
}

let data = "{ \"type\": \"foo\" }".data(using: .utf8)!
let state = try! JSONDecoder().decode(State.self, from: data)

Thanks @iampatbrown for the rubber ducking! 🦆