Wie kann ich testen, die Gleichwertigkeit der Aufzählung Fälle mit zugehörigen Werten in Swift 4

Question

Ich möchte die Äquivalenz von ein paar Variablen von Aufzählungstypen testen, wie folgt aus:

enum AnEnumeration { 
    case aSimpleCase 
    case anotherSimpleCase 
    case aMoreComplexCase(String) 
} 

let a1 = AnEnumeration.aSimpleCase 
let b1 = AnEnumeration.aSimpleCase 
a1 == b1 // Should be true. 

let a2 = AnEnumeration.aSimpleCase 
let b2 = AnEnumeration.anotherSimpleCase 
a2 == b2 // Should be false. 

let a3 = AnEnumeration.aMoreComplexCase("Hello") 
let b3 = AnEnumeration.aMoreComplexCase("Hello") 
a3 == b3 // Should be true. 

let a4 = AnEnumeration.aMoreComplexCase("Hello") 
let b4 = AnEnumeration.aMoreComplexCase("World") 
a3 == b3 // Should be false. 

Leider alle diese produzieren, diese Fehler zu wie diese:

error: MyPlayground.playground:7:4: error: binary operator '==' cannot be applied to two 'AnEnumeration' operands 
a1 == b1 // Should be true. 
~~^~~ 

MyPlayground.playground:7:4: note: binary operator '==' cannot be synthesized for enums with associated values 
a1 == b1 // Should be true. 
~~^~~ 

Übersetzung: Wenn Ihre Aufzählung zugehörigen Werte verwendet, können Sie es für Gleichwertigkeit nicht testen können.

Hinweis: Wenn .aMoreComplexCase (und die entsprechenden Tests) entfernt wurden, dann würde der Code wie erwartet funktionieren.

Es sieht so aus, als hätten sich die Leute in der Vergangenheit dafür entschieden, das Überladen von Operatoren zu benutzen, um dies zu umgehen: How to test equality of Swift enums with associated values. Aber jetzt, wo wir Swift 4 haben, frage ich mich, ob es einen besseren Weg gibt? Oder wenn Änderungen vorgenommen wurden, die die verknüpfte Lösung ungültig machen?

Danke!

Answer 1

Der Swift Vorschlag

• SE-0185 Synthesizing Equatable and Hashable conformance

wurde in Swift 4.1 (Xcode 9.3, derzeit in der Beta) akzeptiert und umgesetzt:

... synthetisieren Übereinstimmung mit Equatable/Hashable, wenn alle Elemente gleich oder absperrbar sind.

deshalb genügt es,

... Opt-in der automatischen Synthese von ihrer Art als gleichzusetzen oder Hashable erklären ohne die Anforderungen umzusetzen.

In Ihrem Beispiel - da String ist Equatable - es wird

enum AnEnumeration: Equatable { 
    case aSimpleCase 
    case anotherSimpleCase 
    case aMoreComplexCase(String) 
} 

und der Compiler Synthese eines geeigneten == Operator zu erklären genügen.