Propagate

// Handling a fallible with `match` or `catch` is right when this function is the one that should
// decide what a failure means. Often it is not: the function is a step in the middle, and a
// failure should simply become the caller's problem.
//
// Written by hand that is the same few lines every time: match, keep the success, fail with the
// error unchanged. Postfix `?` is those lines written once. On success, `step?` is the value
// inside. On failure, the enclosing function fails at once with that same error, and nothing after
// the `?` runs.
import Io::PrintLine;

variant DigitError {
    Blank,
    NotADigit(char)
}

// One small step that can fail.
func ReadDigit(c: char) -> int ! DigitError {
    if c == ' ' {
        fail DigitError::Blank;
    }
    if c < '0' || c > '9' {
        fail DigitError::NotADigit(c);
    }
    return (c as int) - ('0' as int);
}

// The long way. Each failure is matched only to be handed straight back to the caller: two
// near-identical blocks that say nothing new.
func TwoDigitsByHand(tens: char, units: char) -> int ! DigitError {
    var high = 0;
    match ReadDigit(tens) {
        .Success(value) => high = value,
        .Failure(error) => fail error
    }
    var low = 0;
    match ReadDigit(units) {
        .Success(value) => low = value,
        .Failure(error) => fail error
    }
    return high * 10 + low;
}

// The same function with `?`. The success values are used straight away.
func TwoDigits(tens: char, units: char) -> int ! DigitError {
    let high = ReadDigit(tens)?;
    let low = ReadDigit(units)?;
    return high * 10 + low;
}

func Show(outcome: int ! DigitError) {
    match outcome {
        .Success(value) => PrintLine("read {}", value),
        .Failure(DigitError::Blank) => PrintLine("a digit is missing"),
        .Failure(DigitError::NotADigit(c)) => PrintLine("'{}' is not a digit", c)
    }
}

func Main() -> int {
    Show(TwoDigits('4', '2'));
    Show(TwoDigits('4', 'x'));
    Show(TwoDigits('?', '2'));
    Show(TwoDigits(' ', '7'));

    // Both versions behave identically: `?` is shorthand, not a different rule.
    Show(TwoDigitsByHand('4', 'x'));

    // The error travels intact. Neither `TwoDigits` nor `?` looked at it, yet the caller still
    // learns which character was wrong.
    //
    // `?` has two requirements. The function using it must itself be fallible, since that is
    // where the failure goes. In `Main`, which returns a plain `int`, `ReadDigit('4')?` is
    // rejected: "'?' propagates native fallible 'int ! DigitError', but the enclosing function
    // returns 'int'". And the error must fit that function's error type. Here both are
    // `DigitError`, so it passes through as is.
    return 0;
}