Swift Compiler Error: Der Enum-Fall hat ein einzelnes Tupel als zugeordneten Wert, aber hier gibt es mehrere Muster

Beim Erstellen eines Projekts in Xcode 11.4 Beta 3 wird dieser Swift Compiler-Fehler in einer Aufzählung angezeigt:

Der Enum-Fall hat ein einzelnes Tupel als zugeordneten Wert, aber hier gibt es mehrere Muster, die implizit die Muster tupeln und stattdessen versuchen, diese abzugleichen

Quellcode:

switch result {
case .error(let err):
    //
case .value(let staff, let locations):  // <-- error on this line
    //
}

Resultist eine generische Aufzählung mit zugehörigen Werten für .errorund .value. In diesem Fall ist der zugehörige Wert ein Tupple.

public enum Result<T> {
    case value(T)
    case error(Error)
}

Erinnern Sie sich nicht, diesen Fehler zuvor gesehen zu haben, und die Suche danach ergab keine Ergebnisse. Irgendwelche Ideen?

Ich habe festgestellt, dass Sie diesen Fehler auch zum Schweigen bringen können, indem Sie den zugehörigen Wert eher wie ein Tupel behandeln, indem Sie ihn in zusätzliche Klammern setzen:

switch result {
case .error(let err):
    //
case .value((let staff, let locations)):  
    //
}

Ok, habe es herausgefunden. Scheint so, als ob enummit zugeordneten Werten, bei denen der Werttyp ein Tupple ist, eine switch-Anweisung wie diese nicht mehr abgeglichen werden kann:

// Works on Xcode 11.3.1, yields error on 11.4 (Swift 5.2)
switch result {
case .error(let err):
    //
case .value(let staff, let locations):  
    //
}

Lösung

Werte aus tupple müssen in Xcode 11.4 (Swift 5.2) manuell extrahiert werden:

// Works on Xcode 11.4
switch result {
case .error(let err):
    //
case .value(let tupple):  
    let (staff, locations) = tupple
    // 
}

Dies ist ein bekanntes Problem: https://developer.apple.com/documentation/xcode_release_notes/xcode_11_4_release_notes

Code, bei dem der Compiler ein Muster automatisch tupft, kann beim Upgrade auf Xcode 11.4 zu einem Compilerfehler führen, obwohl der Code zuvor kompiliert wurde. (58425942)

Das Auslassen von Klammern beim Einschalten eines optionalen Tupeltyps führt beispielsweise zu einem Compilerfehler:

switch x { // error: switch must be exhaustive
case .some((let a, let b), let c): // warning: the enum case has a
     // single tuple as an associated value, but there are several
     // patterns here, implicitly tupling the patterns and trying
     // to match that instead
...

}}

Problemumgehung : Fügen Sie zusätzliche Klammern hinzu, um das Muster explizit zu tupeln :

switch x {
case .some(((let a, let b), let c)): // Notice the extra pair of parentheses.
...

}}

Wenn ich darf, möchte ich auch eine Antwort für die if caseVersion hinzufügen .

if case let .value(staff, error) = result {
    // Do something
}

und dann natürlich den Fall ignorieren:

if case let .value(staff, _) = result {
    // Do something
}