Warum ist gleichzusetzen nicht für optionalen Arrays definiert

Question

Kann mir jemand einen guten Grund geben, warum dies nicht funktioniert:

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

Das wäre meine vorgeschlagen (wenn unelegant) Lösung sein. Aber es ist trivial, also habe ich das Gefühl, dass ich einen guten Grund vermisse, warum das nicht umgesetzt wird.

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

Optionals können nur verglichen werden, wenn der Basiswert umschlossenen Typ gleichzusetzen ist:

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

Jetzt Arrays verglichen sein kann, wenn der Typ Element ist gleichzusetzen:

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

aber auch für gleichwertige Typen T, Array<T>entspricht nicht zu dem Equatable Protokoll.

Derzeit dies in Swift nicht möglich ist, siehe zum Beispiel Why can't I make Array conform to Equatable? für eine Diskussion im Apple-Entwickler-Forum. Diese Änderung bei der Umsetzung von SE-0143 Conditional conformances in Swift 4.

Ihre Implementierung korrekt aussieht, hier ist eine mögliche anderes mit dem Schalter/Fall mit Mustervergleich:

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 
    } 
}