Wörterbuch der optionalen Tasten

Question

Gibt es eine Problemumgehung, um ein Wörterbuch mit Optional Schlüsseln zu erstellen? Ich weiß, dass eine angemessene Lösung dafür die Umsetzung von Conditional Conformances erfordert, aber habe ich vorher irgendwelche Optionen?

let dict: [Int?: Int] = [nil: 1] 
// ERROR: type 'Int?' does not conform to protocol 'Hashable' 

Answer 1

Hier ist eine Abhilfe, die ich gefunden: Erstellen Sie ein neues HashableOptionalenum:

enum HashableOptional<Wrapped: Hashable> { 
    case none 
    case some(Wrapped) 

    public init(_ some: Wrapped) { 
     self = .some(some) 
    } 

    public init(_ optional: Wrapped?) { 
     self = optional.map{ .some($0) } ?? .none 
    } 

    public var value: Wrapped? { 
     switch self { 
      case .none: return nil 
      case .some(let wrapped): return wrapped 
     } 
    } 
} 

extension HashableOptional: Equatable { 
    static func ==(lhs: HashableOptional, rhs: HashableOptional) -> Bool { 
     switch (lhs, rhs) { 
      case (.none, .none): return true 
      case (.some(let a), .some(let b)): return a == b 
      default: return false 
     } 
    } 
} 

extension HashableOptional: Hashable { 
    var hashValue: Int { 
     switch self { 
      case .none: return 0 
      case .some(let wrapped): return wrapped.hashValue 
     } 
    } 
} 

extension HashableOptional: ExpressibleByNilLiteral { 
    public init(nilLiteral:()) { 
     self = .none 
    } 
} 

Und dann kann man es wie so verwenden:

let dict: [HashableOptional<Int>: Int] = [nil: 1]