Pattern matching

// `match` is an expression: every arm yields a value, and the
// whole match evaluates to the arm that fits. Here we match on
// integer literals, with a wildcard `_` as the catch-all.
fn grade(score: int) -> string {
    return match score {
        100 => "perfect",
        90 => "A",
        80 => "B",
        _ => "keep going"
    }
}

// String and bool literals match the same way.
fn greet(lang: string) -> string {
    return match lang {
        "en" => "hello",
        "no" => "hei",
        _ => "..."
    }
}

println(grade(100))
println(grade(80))
println(grade(42))
println(greet("no"))
println(greet("fr"))

// A bare name in a pattern is a binding: it matches anything and
// binds the value, so you can use it on the right-hand side. A guard
// (`if cond`) refines an arm — the arm only fires when the guard holds.
fn classify(n: int) -> string {
    return match n {
        0 => "zero",
        x if x < 0 => "negative",
        x if x % 2 == 0 => "even",
        x => "odd: ${x}"
    }
}

println(classify(0))
println(classify(-7))
println(classify(8))
println(classify(3))

// Tuple patterns destructure positionally — and the elements can be
// literals, bindings, or nested tuples. Classifying a point by which
// axis it sits on falls out naturally.
fn quadrant(p: (int, int)) -> string {
    return match p {
        (0, 0) => "origin",
        (0, y) => "on the y-axis",
        (x, 0) => "on the x-axis",
        (x, y) => "at (${x}, ${y})"
    }
}

// Nesting works too: a pattern can reach into an inner tuple.
fn label(p: ((int, int), int)) -> string {
    return match p {
        ((0, 0), z) => "axis origin, depth ${z}",
        ((x, y), 0) => "flat at (${x}, ${y})",
        ((x, y), z) => "point in space"
    }
}

println(quadrant((0, 0)))
println(quadrant((0, 5)))
println(quadrant((3, 4)))
println(label(((0, 0), 9)))
println(label(((1, 2), 0)))

// Constructor patterns match enum variants. Qualify the variant with
// `Enum::Variant`, and bind any payload right in the pattern.
enum Shape {
    Circle(int),
    Rect(int, int),
    Point
}

fn area(s: Shape) -> int {
    return match s {
        Shape::Circle(r) => 3 * r * r,
        Shape::Rect(w, h) => w * h,
        Shape::Point => 0
    }
}

println(area(Shape::Circle(10)))
println(area(Shape::Rect(3, 4)))
println(area(Shape::Point))

// A generic enum makes its own Option type. Matching binds the
// payload of `Some`, and the checker forces you to handle `None`.
enum Opt<T> {
    Some(T),
    None
}

fn unwrap_or(o: Opt<int>, fallback: int) -> int {
    return match o {
        Opt::Some(v) => v,
        Opt::None => fallback
    }
}

println(unwrap_or(Opt::Some(42), 0))
println(unwrap_or(Opt::None, -1))

// Struct patterns destructure named fields in a `let` binding: pull
// the fields you want straight out of a value into local names.
struct Point {
    x: int,
    y: int
}

fn main() {
    let p = Point { x: 3, y: 4 }

    // Destructure both fields by name.
    let { x, y } = p
    println("x is ${x}, y is ${y}")

    // Shorthand binds each field to a variable of the same name.
    let origin = Point { x: 0, y: 0 }
    let { x: ox, y: oy } = origin
    println("origin: (${ox}, ${oy})")
}

main()

// Matching every variant of an enum satisfies the exhaustiveness
// checker. No wildcard needed — the compiler can see all cases are
// covered, so this compiles and runs.
enum Signal {
    Red,
    Amber,
    Green
}

fn action(s: Signal) -> string {
    return match s {
        Signal::Red => "stop",
        Signal::Amber => "slow",
        Signal::Green => "go"
    }
}

println(action(Signal::Red))
println(action(Signal::Amber))
println(action(Signal::Green))

// @expect-error
// This match omits `Signal::Green` and has no wildcard, so the
// checker rejects it at compile time — before any bytecode runs.
enum Signal {
    Red,
    Amber,
    Green
}

fn action(s: Signal) -> string {
    return match s {
        Signal::Red => "stop",
        Signal::Amber => "slow"
    }
}

println(action(Signal::Red))