AI writes the code. You control what it touches.

The syntax

match takes a value, compares it against patternson the left of each =>, and evaluates the expression on the right of the matching arm. The whole match expression returns that value — like an expression-orientedswitch in other languages.

match <value> {
    <pattern> => <expression>,
    <pattern> => <expression>
}

You can also write switch s { case Circle(r): … } — it desugars tomatch with the same exhaustiveness rules.

Matching enums — Circle(r)

Enums are tagged unions. You construct with the enum name (Shape::Circle(2)) but match with bare variant names. Parentheses bind the payload into variables:

enum Shape {
    Circle(int),
    Rect(int, int)
}

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

• Circle(r) — if s is a circle, bind its radius to r and run3 * r * r
• Rect(w, h) — if s is a rectangle, bind width and height
• Exhaustive — omit Rect andvow check fails. Every variant must have an arm.

Tutorial:Structs, enums, and match

Matching options — Some / None

Option<T> is a built-in enum with variants Some(value) andNone. Same pattern: bind the inner value in the pattern, handle absence in the other arm.

main(caps: Caps) fields like caps.net and caps.fs_read areOption<Cap> — Some when you passed --grant, Nonewhen you did not:

return match caps.net {
    Some(cap) => serve.listen(a, cap, 8787),
    None => 0 - 1,
};

Without --grant net:, caps.net is None and the program returns0 - 1 instead of calling serve.listen.

Matching results — Ok / Err (not try/catch)

Result<T, E> is another enum: Ok(value) on success, Err(code)on failure. I/O builtins return Result; you match or use try/catchsugar — not stack-unwinding exceptions.

Some(cap) => … answers “was the grant passed?” Ok(s) => … answers “did the read succeed?” They look similar because both use match, but they mean different things.

return match caps.fs_read {
    Some(c) => with c { read_config("/data/users.json") },
    None => 0 - 1,
};

return match read_file(path) {
    Ok(s) => len(s),
    Err(_) => 0 - 1,
};

Full tutorial:Option & Result·Control flow·Capabilities