Dlaczego Equatable nie zdefiniowane dla opcjonalnych tablic

Question

Czy ktoś może dać mi dobry powód, dlaczego to nie działa:

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

Byłoby to rozwiązanie proponowane moje (jeśli nieeleganckie). Ale to trywialne, więc czuję, że brakuje mi dobrego powodu, dla którego nie jest to realizowane.

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

opcjonalne mogą być porównywane tylko wtedy, gdy instrumentem bazowym owinięty typ jest equatable:

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

Teraz Tablice mogą być porównaniu jeśli typ elementem jest equatable:

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

ale nawet dla typów równoważnych T, Array<T>nie spełnia do protokołu Equatable.

Obecnie nie jest to możliwe w witrynie Swift, zobacz na przykład Why can't I make Array conform to Equatable? dla dyskusji na forum programistów Apple. Ta zmiana z realizacją z SE-0143 Conditional conformances w Swift 4.

Implementacja wygląda poprawnie, tutaj jest możliwa inna za pomocą przełącznika/sprawy z pasującymi Wzór:

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