Calculator

// Calculator: a pocket calculator that works on 32-bit integers and says exactly why when it
// cannot give an answer.
//
// A real calculator shows "E" and leaves you guessing. This one has an error variant with one case
// for each way a sum can go wrong, carrying whatever detail explains it: dividing by zero, a key
// that is not an operator, and an answer too large for an `int32`.
//
// The arithmetic happens in `int64`, where no two `int32` values can overflow, and the answer is
// then checked on its way back down. That catches the cases people expect, such as 2147483647 + 1,
// and one they usually do not: -2147483648 / -1, whose answer is one more than an `int32` holds.
//
// The program uses each of the main tools from the Errors part. `Apply` raises one with
// `fail`. `Run` passes one on with `?`, so a tape of key presses stops at the first bad step.
// `Show` and `Explain` take one apart with `match`. And the forgiving calculator at the end uses
// `catch` to skip a bad step and carry on.
import Io::{ Print, PrintLine };

variant CalcError {
    DivisionByZero,
    UnknownOperator(char),
    Overflow(int64)
}

// Brings a wide answer back to `int32`, or fails if it does not fit.
func Narrow(wide: int64) -> int32 ! CalcError {
    if wide > 2147483647 || wide < -2147483648 {
        fail CalcError::Overflow(wide);
    }
    return wide as int32;
}

func Apply(left: int32, op: char, right: int32) -> int32 ! CalcError {
    if (op == '/' || op == '%') && right == 0 {
        fail CalcError::DivisionByZero;
    }
    let a = left as int64;
    let b = right as int64;
    // An arm may fail instead of producing a value: an unknown key ends the function right there.
    let wide = match op {
        '+' => a + b,
        '-' => a - b,
        '*' => a * b,
        '/' => a / b,
        '%' => a % b,
        else => fail CalcError::UnknownOperator(op)
    };
    return Narrow(wide)?;
}

// Presses the keys of a tape one after another, starting from `start`. The first step that fails
// fails the whole run, and `?` is all it takes to say so.
func Run(start: int32, tape: (char, int32)[..]) -> int32 ! CalcError {
    var total = start;
    for step in tape {
        let (op, operand) = step;
        total = Apply(total, op, operand)?;
    }
    return total;
}

func Explain(error: CalcError) {
    match error {
        .DivisionByZero => PrintLine("error: division by zero"),
        .UnknownOperator(op) => PrintLine("error: '{}' is not an operator", op),
        .Overflow(wide) => PrintLine("error: {} does not fit in an int32", wide)
    }
}

func Show(outcome: int32 ! CalcError) {
    match outcome {
        .Success(answer) => PrintLine("{}", answer),
        .Failure(error) => Explain(error)
    }
}

func PrintTape(start: int32, tape: (char, int32)[..]) {
    Print("{}", start);
    for step in tape {
        let (op, operand) = step;
        Print(" {} {}", op, operand);
    }
    Print(" = ");
}

func Main() -> int {
    let sums: (int32, char, int32)[9] = [
        (12, '+', 30),
        (7, '*', 6),
        (17, '%', 5),
        (7, '/', 0),
        (7, '%', 0),
        (2, '^', 8),
        (2147483647, '+', 1),
        (-2147483648, '/', -1),
        (65536, '*', 65536)
    ];
    for sum in sums {
        let (left, op, right) = sum;
        Print("{} {} {} = ", left, op, right);
        Show(Apply(left, op, right));
    }
    PrintLine();

    // A tape is a run of key presses, each applied to the answer so far. Like a pocket calculator,
    // it works strictly left to right, with no precedence: 1 + 2 * 3 is 9 on a tape, not 7.
    let good: (char, int32)[4] = [('+', 10), ('*', 7), ('-', 6), ('/', 8)];
    let bad: (char, int32)[5] = [('+', 10), ('/', 0), ('*', 7), ('x', 2), ('-', 6)];
    PrintTape(0, good);
    Show(Run(0, good));
    PrintTape(0, bad);
    Show(Run(0, bad));

    // A forgiving calculator ignores a key it cannot use. `catch { else => total }` keeps the
    // answer it already had, whatever went wrong, and the tape carries on past the bad steps.
    var total: int32 = 0;
    for step in bad {
        let (op, operand) = step;
        total = Apply(total, op, operand) catch { else => total };
    }
    PrintLine("skipping the bad keys instead: {}", total);
    return 0;
}