Why doesn't Int64 automatically conform to CodingKeyRepresentable?

[tomhamming]

I came here originally to ask why Int64 can't be used as a JSON dictionary key by JsonEncoder even though Int can. I discovered various posts about this, and ultimately that types besides Int and String can be used as dictionary keys as of SE-0320 in Swift 5.6. I was able to add CodingKeyRepresentable to Int64 myself by serializing it to a string and back, and it seems to work great.

struct MyCodingKey: CodingKey {
    let stringValue: String
    let intValue: Int?
    
    init(stringValue: String) {
        self.stringValue = stringValue
        self.intValue = Int(stringValue)
    }
    
    init(intValue: Int) {
        self.stringValue = "\(intValue)"
        self.intValue = intValue
    }
}

extension Int64 : CodingKeyRepresentable {
    public var codingKey: CodingKey {
        MyCodingKey(stringValue: "\(self)")
      }
      public init?<T: CodingKey>(codingKey: T) {
          if let intValue = Int64(codingKey.stringValue) {
          self = intValue
        } else {
          return nil
        }
      }
}

I still wonder, though: why isn't CodingKeyRepresentable conformance built-in on Int64?

[tomhamming]

I found the answer here:

[Pitch] Allow coding of non-`String`/`Int` keyed `Dictionary` into a `KeyedContainer`

While it's not recommended you conform types you don't own to protocols you don't own, until Int64 adopts CodingKeyRepresentable, you could implement a conformance as follows: // Need a key type which can hold any Int value. struct IntCodingKey: CodingKey { let intValue: Int? let stringValue: String init(intValue: Int) { self.intValue = intValue self.stringValue = String(describing: intValue) } init?(stringValue: String) { guard let intValue = Int(s…

And as to why Int64 wasn't originally supported as a key: it's tricky to read back out.

Dictionarys encoding strategy

There are two answers to your questions here: There are corner cases here around integer coding keys which don't always have good answers. The biggest issue to deal with is conversion between integer sizes: It's always safe to promote an integer type smaller than Int to an Int, so it would be possible to encode those values as CodingKeys. On decode, though, you could get a CodingKey whose integer value does not fit in, say, an Int8. You could consider this to be a type mismatch, potentially,…

Hopefully this question makes that more discoverable by search.