Dictionnaire des clés optionnelles

Question

Existe-t-il une solution de contournement pour créer un dictionnaire avec les clés Optional? Je sais qu'une solution appropriée pour cela nécessiterait la mise en œuvre de conformations conditionnelles, mais ai-je des options avant cela?

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

Answer 1

Voici une solution de contournement j'ai trouvé: Créer une nouvelle 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 
    } 
} 

Et vous pouvez alors l'utiliser comme ceci:

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