Error variant

// An operation that can go wrong in several ways deserves an error type that lists those ways.
// A variant does that: one case per kind of failure, and each case carries only the details that
// make sense for it.
//
// A case with nothing to add is bare. A case with one fact carries it in parentheses. A case with
// several facts gives them names, like a small struct. The caller can then match on the case to
// decide what to do, and read the details to say precisely what went wrong — far more than a
// single error code could tell it.
import Io::PrintLine;

variant TransferError {
    SameAccount,
    UnknownAccount(int),
    ShortOfFunds { balance: int; requested: int; }
}

// Turns an account number into a position in the list of balances.
func Find(number: int) -> int ! TransferError {
    if number < 1 || number > 3 {
        fail TransferError::UnknownAccount(number);
    }
    return number - 1;
}

func Transfer(balances: &var int[3], from: int, to: int, amount: int) -> ! TransferError {
    if from == to {
        fail TransferError::SameAccount;
    }
    // The same error type all the way through, so `?` passes each failure on unchanged.
    let source = Find(from)?;
    let target = Find(to)?;
    if balances[source] < amount {
        fail TransferError::ShortOfFunds { balance: balances[source], requested: amount };
    }
    balances[source] -= amount;
    balances[target] += amount;
}

// One message per case, each built from the details that case carries.
func Explain(error: TransferError) {
    match error {
        .SameAccount => PrintLine("    refused: an account cannot pay itself"),
        .UnknownAccount(number) => PrintLine("    refused: there is no account {}", number),
        .ShortOfFunds { balance, requested } => PrintLine(
            "    refused: asked for {} but only {} is there", requested, balance)
    }
}

func Attempt(balances: &var int[3], from: int, to: int, amount: int) {
    PrintLine("move {} from account {} to account {}", amount, from, to);
    match Transfer(balances, from, to, amount) {
        .Success(()) => PrintLine("    done: balances {}, {}, {}", balances[0], balances[1],
            balances[2]),
        .Failure(error) => Explain(error)
    }
}

func Main() -> int {
    var balances: int[3] = [100, 50, 0];
    Attempt(balances, 1, 3, 30);
    Attempt(balances, 2, 2, 10);
    Attempt(balances, 1, 7, 10);
    Attempt(balances, 3, 1, 45);
    return 0;
}