Błąd szybkiego kompilatora: Przypadek wyliczenia ma pojedynczą krotkę jako powiązaną wartość, ale tutaj jest kilka wzorców

Budując projekt w Xcode 11.4 beta 3, pojawia się błąd Swift Compiler na wyliczeniu:

Przypadek wyliczenia ma pojedynczą krotkę jako powiązaną wartość, ale istnieje tutaj kilka wzorców, domyślnie krotkując wzorce i próbując je dopasować

Kod źródłowy:

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

Resultjest ogólnym wyliczeniem z powiązanymi wartościami dla .errori .value. W tym przypadku powiązaną wartością jest krotka.

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

Nie przypominaj sobie wcześniej, aby widział ten błąd, a wyszukiwanie go nie przyniosło żadnych rezultatów. Jakieś pomysły?

Odkryłem, że możesz również wyciszyć ten błąd, traktując skojarzoną wartość bardziej jak krotkę, zawijając ją w dodatkowy zestaw nawiasów:

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

Ok, rozgryzłem to. Wygląda na to, że enumz powiązanymi wartościami, w których typem wartości jest krotka, nie można już dopasować takiej instrukcji switch w ten sposób:

// 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):  
    //
}

Rozwiązanie

Wartości z krotek należy ręcznie wyodrębnić w Xcode 11.4 (Swift 5.2):

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

Jest to znany problem: https://developer.apple.com/documentation/xcode_release_notes/xcode_11_4_release_notes

Kod oparty na kompilatorze automatycznie tupujący wzorzec może prowadzić do błędu kompilatora podczas aktualizacji do Xcode 11.4, nawet jeśli kod został skompilowany wcześniej. (58425942)

Na przykład pominięcie nawiasów podczas włączania Opcjonalnego typu krotki powoduje błąd kompilatora:

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

}

Obejście : Dodaj dodatkowe nawiasy, aby jawnie krotnie wzorzec:

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

}

Jeśli mogę, chciałbym również dodać odpowiedź dla if casewersji.

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

a następnie oczywiście ignorując wielkość liter:

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