Perché equatable non definiti per gli array opzionali

Question

Qualcuno può darmi una buona ragione per cui questo non funziona:

let a: [Int]? = [1] 
let b: [Int]? = nil 
a == b 

Questa sarebbe la mia soluzione proposta (se poco elegante). Ma è banale, quindi mi sento come se mi mancasse una buona ragione per cui questo non è implementato.

func ==<T: Equatable>(lhs: [T]?, rhs: [T]?) -> Bool { 

    if let lhs = lhs, let rhs = rhs { 
     return lhs == rhs 
    } 
    else if let _ = lhs { 
     return false 
    } 
    else if let _ = rhs { 
     return false 
    } 

    return true 
} 

Answer 1

Optional può essere paragonato solo se il tipo avvolto sottostante è equatable:

public func ==<T : Equatable>(lhs: T?, rhs: T?) -> Bool 

ora array possono essere rispetto se il tipo di elemento è equatable:

/// Returns true if these arrays contain the same elements. 
public func ==<Element : Equatable>(lhs: [Element], rhs: [Element]) -> Bool 

ma anche per tipi uguali T, Array<T>non conforme al protocollo Equatable.

Allo stato attuale, questo non è possibile in Swift, vedere ad esempio Why can't I make Array conform to Equatable? per una discussione nel forum degli sviluppatori Apple. Questo cambiamento con l'attuazione di SE-0143 Conditional conformances a Swift 4.

L'implementazione è corretto, ecco un possibile differente utilizzando switch/case con pattern matching:

func ==<T: Equatable>(lhs: [T]?, rhs: [T]?) -> Bool { 

    switch (lhs, rhs) { 
    case let (l?, r?) : // shortcut for (.Some(l), .Some(r)) 
     return l == r 
    case (.None, .None): 
     return true 
    default: 
     return false 
    } 
}