Match Expressions

Match expressions provide pattern matching for clean, exhaustive branching.

Basic Syntax

match value {
    pattern1 => result1,
    pattern2 => result2,
    _ => default_result
}

The _ is a wildcard that matches any value not handled by previous arms.

Matching Integers

function describe(x: i32) i32 {
    return match x {
        1 => 100,
        2 => 200,
        3 => 300,
        _ => 0
    };
}

function main() i32 {
    return describe(2);  // Returns 200
}

Match as Expression

Match is an expression, so it returns a value that can be used directly:

function main() i32 {
    var x = 2;
    var result = match x {
        1 => 10,
        2 => 20,
        _ => 0
    };
    return result;  // 20
}

You can use match anywhere an expression is expected:

function main() i32 {
    var x = 1;
    var y = 10 + match x {
        1 => 5,
        _ => 0
    };
    return y;  // 15
}

Block Bodies

Use braces for multi-statement arm bodies:

function main() i32 {
    var x = 2;
    match x {
        1 => {
            var a = 10;
            return a + 5;
        },
        2 => {
            var b = 20;
            return b + 5;
        },
        _ => {
            return 0;
        }
    };
    return 0;
}

Matching Booleans

function main() i32 {
    var flag = true;
    return match flag {
        true => 1,
        false => 0,
        _ => 99
    };
}

Matching Enums

Match works naturally with enum types:

enum Color { Red, Green, Blue }

function to_code(c: Color) i32 {
    return match c {
        Color.Red => 1,
        Color.Green => 2,
        Color.Blue => 3,
        _ => 0
    };
}

function main() i32 {
    var c: Color = Color.Green;
    return to_code(c);  // 2
}

Match as Statement

Use match as a statement for side effects:

function main() i32 {
    var x = 2;
    var result = 0;
    match x {
        1 => { result = 10; },
        2 => { result = 20; },
        _ => { result = 99; }
    };
    return result;  // 20
}

Return from Match Arms

You can return from the enclosing function inside a match arm:

function process(x: i32) i32 {
    match x {
        1 => { return 10; },
        2 => { return 20; },
        _ => { return 99; }
    };
    return 0;  // Never reached if all cases return
}

Nested Match

Match expressions can be nested:

function main() i32 {
    var x = 1;
    var y = 2;
    return match x {
        1 => match y {
            1 => 11,
            2 => 12,
            _ => 10
        },
        2 => 20,
        _ => 0
    };  // Returns 12
}

No Match Fallthrough

If no arm matches and there's no wildcard _, execution continues after the match:

function main() i32 {
    var x = 99;
    match x {
        1 => { return 10; },
        2 => { return 20; }
    };
    return 0;  // Reached when x is neither 1 nor 2
}

⚠️

Without a wildcard arm, unmatched values will fall through silently. Consider always including a _ arm for safety.

Trailing Commas

Trailing commas are allowed:

match x {
    1 => 10,
    2 => 20,
    _ => 0,
}

Different Integer Sizes

Match handles different integer sizes (i32, i64, etc.):

function main() i32 {
    var x: i64 = 2;
    var result: i64 = match x {
        1 => 100,
        2 => 200,
        _ => 0
    };
    return result;  // 200
}

Currently, match supports equality matching only. Future versions will add support for pattern destructuring, guards, and range patterns.

Control Flow Enums