do, try, catch

Fa parte della sezione Logica e flusso del percorso Swift di Coddy. Lezione 45 di 56.

La forma completa per gestire gli errori è do/try/catch:

enum DivError: Error { case byZero }

func divide(_ a: Int, _ b: Int) throws -> Int {
    if b == 0 { throw DivError.byZero }
    return a / b
}

do {
    let r = try divide(10, 2)
    print(r)                      // 5
} catch DivError.byZero {
    print("can't divide by zero")
} catch {
    print("unknown error")
}

try va prima di qualsiasi chiamata che può generare un errore. Se la chiamata genera un errore, il controllo passa al catch corrispondente; altrimenti, l’esecuzione prosegue oltre il blocco do.

Le clausole catch multiple vengono eseguite dall'alto verso il basso e vince la prima corrispondenza, proprio come in uno switch. Il catch senza argomenti alla fine è il caso predefinito: quasi sempre è opportuno inserirne uno per evitare errori del compilatore.

Sfida

Facile

Definisci un enum ParseError: Error con tre casi: empty, notInteger e negative.

Definisci una funzione che può generare errori parsePositive(_ s: String) throws -> Int che:

Genera .empty quando s, dopo aver rimosso gli spazi bianchi, è vuota
Genera .notInteger quando s non può essere analizzata come Int
Genera .negative quando il valore analizzato è < 0
Altrimenti restituisce il valore analizzato

Leggi una singola riga da stdin e chiama parsePositive in un blocco do/catch. Stampa:

got: <n> in caso di successo
error: empty, error: not integer o error: negative per ciascun caso

Per l'input 42, l'output è got: 42. Per una riga vuota, è error: empty. Per abc è error: not integer.

Provalo tu

let line = readLine()!

// TODO: enum ParseError; func parsePositive(_:) throws -> Int;
// do/try/catch con tre rami più il ramo che gestisce tutti gli altri casi