Enum

// An enum is a type with a fixed list of named values, called its cases. A direction is north,
// east, south or west, and nothing else. Stored as an `int`, a direction could just as well be
// 47, and nothing would notice; stored as a `Direction`, it cannot.
//
// The cases carry no data; each one is simply itself. A case that needs to carry something is a
// `variant`, two lessons on.
import Io::PrintLine;

enum Direction {
    North,
    East,
    South,
    West
}

// An enum can be extended with methods like any other type. Taking `self` by value is natural
// here: a case is as small as a number.
extend Direction {
    // Inside a `match` on a `Direction`, the type is already known, so a pattern may be written
    // `.North` rather than `Direction::North`. A value outside a pattern is written in full:
    // `.North => .East` stops with
    //     error: '.East' must be written in full, as in 'Direction::East'
    func TurnRight(self: Direction) -> Direction {
        return match self {
            .North => Direction::East,
            .East => Direction::South,
            .South => Direction::West,
            .West => Direction::North
        };
    }

    // An enum cannot be printed with `{}` directly, so it is given a name to print.
    func Name(self: Direction) -> char8[..] {
        return match self {
            .North => "north",
            .East => "east",
            .South => "south",
            .West => "west"
        };
    }
}

func Main() -> int {
    // A case is named through its type.
    var heading = Direction::North;
    PrintLine("start facing {}", heading.Name());

    for turn in 1..=4 {
        heading = heading.TurnRight();
        PrintLine("turn {}: facing {}", turn, heading.Name());
    }

    // Cases compare with `==` and `!=`.
    PrintLine("back to north: {}", heading == Direction::North);
    PrintLine("facing east:   {}", heading == Direction::East);

    // Neither `match` above needs an `else`: naming all four cases covers every value a
    // `Direction` can hold. Add a fifth case, and both stop compiling until they handle it.
    return 0;
}