העברת שגיאות הלאה

חלק מהיחידה לוגיקה וזרימת תוכנית במסלול ה-Swift של Coddy. שיעור 47 מתוך 56.

פונקציה שזורקת שגיאה יכולה לקרוא לפונקציות אחרות שזורקות שגיאה. השגיאה מתפשטת אוטומטית עד ל־do/catch הקרובים ביותר, ואין צורך לזרוק אותה מחדש באופן ידני.

enum AuthError: Error { case badUser, badPass }

func loadUser(_ name: String) throws -> String {
    if name.isEmpty { throw AuthError.badUser }
    return name
}

func login(_ name: String, _ pass: String) throws -> String {
    let u = try loadUser(name)            // מעביר את השגיאה הלאה
    if pass.count < 4 { throw AuthError.badPass }
    return "hello \(u)"
}

do {
    print(try login("", "abcd"))
} catch AuthError.badUser {
    print("missing user")
} catch AuthError.badPass {
    print("weak password")
}

קרא מלמעלה למטה: login קוראת ל־loadUser עם try. אם loadUser זורקת שגיאה, השגיאה מדלגת על גוף הפונקציה של login ומגיעה אל ה־catch החיצוני. כותבים כל שלב כך שייכשל במהירות, ומשאירים למי שקרא לו להחליט מה לעשות.

אתגר

בינוני

בנה צינור עיבוד קטן של שני שלבים שזורקים שגיאות.

הגדר את StepError: Error עם שני מצבים: negative, tooBig.

הגדר את parseSafe(_ s: String) throws -> Int: זורקת את .negative כאשר המספר השלם שפוענח קטן מ־0, אחרת מחזירה אותו. (נניח שהקלט ניתן לפענוח; טיפלת בזה במקום אחר.)

הגדר את capStrict(_ n: Int) throws -> Int: זורקת את .tooBig כאשר n > 100, אחרת מחזירה את n.

הגדר את processStep(_ s: String) throws -> Int, שקוראת ל־parseSafe ואז ל־capStrict, ומאפשרת לכל שגיאה לעבור הלאה.

קרא שורת קלט אחת: רשימה של מחרוזות המופרדות בפסיקים. עבור כל אחת, קרא ל־processStep בתוך do/catch והדפס שורה אחת:

ok: <n> במקרה של הצלחה
negative כאשר parseSafe זרקה שגיאה
too big כאשר capStrict זרקה שגיאה

עבור הקלט 10,-1,200,42, הפלט הוא:

ok: 10
negative
too big
ok: 42

נסו בעצמכם

let parts = readLine()!.components(separatedBy: ",")

// TODO: enum StepError; parseSafe; capStrict; processStep;
// עבור כל חלק, בצע do/try עם processStep, טפל בכל ענף באמצעות catch והדפס