Nested fallible

// Native forms nest, and each level keeps its own meaning. Two shapes come up
// all the time.
//
// `int? ! SensorError` — "read the next value". Three answers are possible:
// a value, no more values (`none`), or the read itself broke (a failure).
// Running out is not an error and a broken sensor is not "no more", so both
// levels are needed. Walking a folder in the `FileSystem` package has exactly
// this shape.
//
// `(int ! RangeError) ! SensorError` — "ask for a result that can itself
// fail". The outer failure means the question never got an answer. A success
// holds the answer, and that answer may be a failure of its own: the sensor
// replied, and what it replied was "out of range".
//
// Levels never merge. An inner failure is ordinary data inside a success, so
// `?` or `catch` on the outer level never touches it. Patterns nest to reach
// every case: `.Success(value?)`, `.Success(none)`, `.Success(.Failure(e))`.
import Io::{ Print, PrintLine };

struct SensorError {
    sensor: int;
}

struct RangeError {
    value: int;
}

// Sensor 1 logged three readings. Sensor 2 broke while reading its third.
func Reading(sensor: int, index: int) -> int? ! SensorError {
    if sensor == 2 && index == 2 {
        fail SensorError { sensor: sensor };
    }
    if index >= 3 {
        return none;
    }
    return 20 + index;
}

// Sensor 1 answers 21, sensor 2 answers with a reading it rejects, and
// sensor 3 does not answer at all.
func SelfTest(sensor: int) -> (int ! RangeError) ! SensorError {
    if sensor == 3 {
        fail SensorError { sensor: sensor };
    }
    if sensor == 2 {
        return .Success(.Failure(RangeError { value: 999 }));
    }
    return .Success(.Success(21));
}

func Main() -> int {
    for sensor in 1..=2 {
        Print("sensor {} log:", sensor);
        for index in 0..10 {
            match Reading(sensor, index) {
                .Success(value?) => Print(" {}", value),
                .Success(none) => {
                    PrintLine(" (end)");
                    break;
                },
                .Failure(e) => {
                    PrintLine(" (sensor {} broke)", e.sensor);
                    break;
                }
            }
        }
    }

    for sensor in 1..=3 {
        match SelfTest(sensor) {
            .Success(.Success(value)) => PrintLine("sensor {} test: reads {}", sensor, value),
            .Success(.Failure(e)) => PrintLine("sensor {} test: {} is out of range",
                sensor, e.value),
            .Failure(e) => PrintLine("sensor {} test: no answer", e.sensor)
        }
    }
    return 0;
}