Error sum

// Some functions can fail in more than one unrelated way. Reading a percentage
// can find a character that is not a digit, or a perfectly good number that
// is bigger than 100. Those are two different error types, and the error
// channel can hold either one:
//
//     func ParsePercent(text: char8[..]) -> int ! (DigitError | RangeError)
//
// `A | B` is a sum: one value that is an `A` or a `B`, and knows which. The
// order does not matter — `(RangeError | DigitError)` is the same type.
//
// The surprise is how little the function body has to do. A `DigitError`
// fits into the wider sum on its own, so `ParseNumber(text)?` passes it on
// unchanged and `fail RangeError { ... }` needs no wrapping either. This is
// called widening: a narrower error always fits into a sum that includes it.
import Io::PrintLine;

struct DigitError {
    position: uint;
}

struct RangeError {
    value: int;
    limit: int;
}

func ParseNumber(text: char8[..]) -> int ! DigitError {
    var total = 0;
    for i in 0..text.length {
        let byte = text[i];
        if byte < c8'0' || byte > c8'9' {
            fail DigitError { position: i };
        }
        total = total * 10 + ((byte as int) - 48);
    }
    return total;
}

func ParsePercent(text: char8[..]) -> int ! (DigitError | RangeError) {
    // A `DigitError` widens into the sum as it passes through `?`.
    let value = ParseNumber(text)?;
    if value > 100 {
        fail RangeError { value: value, limit: 100 };
    }
    return value;
}

// The caller tells the members apart with a typed pattern: `e: DigitError`
// matches only that member and binds it as a plain `DigitError`. The match
// must cover every member of the sum, or the compiler names the missing one.
// Drop the `RangeError` arm and it says "match on 'int ! (DigitError |
// RangeError)' is not exhaustive; missing .Failure(_: RangeError)".
func Show(text: char8[..]) {
    match ParsePercent(text) {
        .Success(percent) => PrintLine("{:5} -> {}%", text, percent),
        .Failure(e: DigitError) => PrintLine("{:5} -> no digit at position {}", text, e.position),
        .Failure(e: RangeError) => PrintLine("{:5} -> {} is over {}", text, e.value, e.limit)
    }
}

func Main() -> int {
    Show("75");
    Show("7%");
    Show("250");
    return 0;
}