Variant match

// A variant's data can only be read once it is known which case is held. `match` does both in
// one step: an arm such as `.Forward(steps)` fits only a `Forward` value, and when it fits, the
// name in the parentheses is a new binding holding that case's data, ready to use in the arm.
//
// That is the guarantee a variant gives. There is no way to read the steps of a `Turn`, because
// no arm can both fit a `Turn` and bind a `Forward`'s data.
import Io::PrintLine;

// A walk is a list of commands, and each command carries what it needs and nothing more.
variant Command {
    Forward(int),
    Turn,
    Jump(int, int),
    Stop
}

// A match producing a value, as in the MatchExpression lesson. A case with several values binds
// them by position, one name each. `_` binds nothing: it is the way to say "a value goes here,
// and this arm does not need it". A case with no data has nothing to bind.
func Cost(command: Command) -> int {
    return match command {
        .Forward(steps) => steps,
        .Turn => 1,
        .Jump(across, _) => across * 2,
        .Stop => 0
    };
}

func Main() -> int {
    let walk: Command[5] = [
        Command::Forward(3),
        Command::Turn,
        Command::Jump(4, 1),
        Command::Forward(2),
        Command::Stop
    ];

    var x = 0;
    var y = 0;
    var facingEast = true;
    var cost = 0;
    for command in walk {
        // A match as a statement, with a block for each arm. The bindings exist only inside
        // their own arm: `steps` is unknown in the `.Jump` arm, and `across` in the others.
        match command {
            .Forward(steps) => {
                if facingEast {
                    x += steps;
                } else {
                    y += steps;
                }
            },
            .Turn => {
                facingEast = !facingEast;
            },
            .Jump(across, up) => {
                x += across;
                y += up;
            },
            .Stop => {
                PrintLine("stopped");
            }
        }
        cost += Cost(command);
        PrintLine("at ({}, {}), cost so far {}", x, y, cost);
    }

    // There is no `else` arm in either match, and none is needed. Every case is named, and a
    // match on a variant must name them all: leave one out, and it does not compile.
    return 0;
}