Discard

// A fallible result cannot be ignored. Calling a fallible function as a bare statement, with
// nothing looking at what it returns, is a compile error — otherwise a failure could vanish
// without anyone noticing.
//
// Sometimes ignoring it is exactly right, though. A cash machine whose receipt printer has run
// out of paper should still hand over the money. For that there is a deliberate discard:
// `F() catch { else => {} };`. It says, in the code, "I know this can fail and it does not
// matter here". `catch` is the subject of a later lesson; for now, read it as that one phrase.
import Io::PrintLine;

struct Printer {
    paper: int;
}

struct OutOfPaper {
}

// A unit fallible: it either printed the receipt or it did not.
func PrintReceipt(printer: &var Printer, amount: int) -> ! OutOfPaper {
    if printer.paper == 0 {
        fail OutOfPaper {};
    }
    printer.paper -= 1;
    PrintLine("    receipt: {} taken", amount);
}

func Withdraw(printer: &var Printer, amount: int) {
    PrintLine("hand over {}", amount);

    // The line below does not compile:
    //
    //     PrintReceipt(printer, amount);
    //
    // error: fallible result of type '! OutOfPaper' is discarded
    //   note: a failure that nothing handles is lost
    //   help: propagate it with '?', recover with 'catch', or match both '.Success' and '.Failure'
    //
    // Writing `let _ = PrintReceipt(printer, amount);` is refused the same way: binding a
    // fallible to `_` does not handle its failure either.

    // The deliberate discard: a missing receipt is not worth stopping for. The empty block `{}`
    // stands in for the missing success, so this works only for a `! E` function. One that
    // succeeds with a value, such as an `int`, is discarded with a match whose arms are
    // `.Success(_) => {}` and `.Failure(_) => {}`.
    PrintReceipt(printer, amount) catch { else => {} };
}

func Main() -> int {
    var printer = Printer { paper: 2 };
    Withdraw(printer, 20);
    Withdraw(printer, 50);
    Withdraw(printer, 10);

    // `PrintLine` itself is not fallible. It returns an optional, `IoError?`, saying whether
    // the console write had trouble, and an optional may be ignored — which is why every lesson
    // so far could call it as a bare statement.
    return 0;
}