Struct pattern

// A variant case can carry named fields, declared like a struct's: `Rectangle { width: int32;
// height: int32; }`. The pattern for such a case looks like the literal that builds it, with
// names where the values were: `.Rectangle { width, height } =>`.
//
// Each field in the pattern binds a variable or tests a value. Four spellings cover what you
// usually need:
//
//     .Circle { radius }                bind the field to a variable of the same name
//     .Circle { radius: r }             bind the field to a name of your choosing
//     .Rectangle { width }              leave out a field you do not need
//     .Circle { radius: 0 }             match only when the field holds this value
//
// Fields are found by name, so their order in the pattern does not matter. A field left out
// matches anything, as if it were written `height: _`, and `.Rectangle {}` leaves out every field.
// Writing `height: _` anyway says "I know about this field and I do not need it".
import Io::PrintLine;

variant Shape {
    Circle { radius: int32; },
    Rectangle { width: int32; height: int32; },
    Triangle { base: int32; height: int32; }
}

// The shorthand: each field arrives under its own name.
func Area(shape: Shape) -> int32 {
    return match shape {
        .Circle { radius } => 3 * radius * radius,
        .Rectangle { width, height } => width * height,
        .Triangle { base, height } => base * height / 2
    };
}

// Renaming and ignoring. `radius: r` reads the radius into `r`; the rectangle leaves out the
// height this question does not need; and the triangle skips it with `height: _`, listing its
// fields in the opposite order.
func Width(shape: Shape) -> int32 {
    return match shape {
        .Circle { radius: r } => 2 * r,
        .Rectangle { width } => width,
        .Triangle { height: _, base } => base
    };
}

// Testing. A literal in a field picks out the cases holding that value. Arms are tried in order, so
// the circle with a `0` comes first and the plain circle arm below it catches every other radius.
// The other arms test no field, so `{}` leaves every field out.
func Kind(shape: Shape) -> char8[..] {
    return match shape {
        .Circle { radius: 0 } => "dot",
        .Circle {} => "circle",
        .Rectangle {} => "rectangle",
        .Triangle {} => "triangle"
    };
}

func Main() -> int {
    let shapes: Shape[4] = [
        Shape::Circle { radius: 5 },
        Shape::Rectangle { width: 4, height: 6 },
        Shape::Triangle { base: 10, height: 3 },
        Shape::Circle { radius: 0 }
    ];
    for index in 0..4 {
        PrintLine("{:9} width {:2}, area {}", Kind(shapes[index]), Width(shapes[index]),
            Area(shapes[index]));
    }
    return 0;
}