Errore del compilatore Swift: il caso enum ha una singola tupla come valore associato, ma qui ci sono diversi schemi

Costruendo un progetto in Xcode 11.4 beta 3, visualizzo questo errore del compilatore Swift su un enum:

Il caso enum ha una singola tupla come valore associato, ma qui ci sono diversi schemi, che ne implicano la tlicazione implicita e cercano invece di abbinarlo

Codice sorgente:

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

Resultè un enum generico con valori associati per .errore .value. In questo caso, il valore associato è un tupple.

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

Non ricordare di aver visto questo errore prima e di averlo cercato non ha prodotto risultati. Qualche idea?

Ho scoperto che puoi anche mettere a tacere questo errore trattando il valore associato più come una tupla avvolgendolo in un set aggiuntivo di parentesi:

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

Ok, capito. Sembra che enumcon i valori associati, in cui il tipo di valore è un tupple, non può più essere associato su un'istruzione switch come quella:

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

Soluzione

I valori da tupple devono essere estratti manualmente in 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
    // 
}

Questo è un problema noto: https://developer.apple.com/documentation/xcode_release_notes/xcode_11_4_release_notes

Il codice che si basa sul compilatore che fa automaticamente il tupling di un modello può portare a un errore del compilatore durante l'aggiornamento a Xcode 11.4, anche se il codice compilato in precedenza. (58425942)

Ad esempio, tralasciando le parentesi quando si attiva un'opzione di tipo tupla si verifica un errore del compilatore:

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

}

Soluzione alternativa : aggiungere parentesi aggiuntive per correggere in modo esplicito il modello:

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

}

Se posso, vorrei aggiungere anche una risposta per la if caseversione.

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

e poi ovviamente ignorando il caso:

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