Pattern Matching

Basic Match

fn describe(n: int) -> string {
    return match n {
        0 => "zero"
        1 => "one"
        _ => "other"
    }
}

Guards

fn classify(n: int) -> string {
    return match n {
        0 => "zero"
        _ if n < 0 => "negative"
        _ if n > 100 => "big"
        _ => "normal"
    }
}

String Matching

fn parse_cmd(cmd: string) -> string {
    return match cmd {
        "quit" => "exiting"
        "help" => "showing help"
        _ => "unknown: ${cmd}"
    }
}

Enum Destructuring

Match on enum variants and extract data:

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

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

Result / Option Patterns

fn safe_div(a: int, b: int) -> Result<int, string> {
    if b == 0 { return Err("division by zero") }
    return Ok(a / b)
}

match safe_div(10, 3) {
    Ok(v) => println("result: ${v}")
    Err(e) => println("error: ${e}")
}

fn find(arr: [int], target: int) -> Option<int> {
    for i in 0..arr.len() {
        if arr[i] == target { return Some(i) }
    }
    return None
}

match find([10, 20, 30], 20) {
    Some(idx) => println("found at ${idx}")
    None => println("not found")
}

Match as Expression

Match can be used as an expression that returns a value:

fn eval(op: string, a: int, b: int) -> Result<int, string> {
    return match op {
        "+" => Ok(a + b)
        "-" => Ok(a - b)
        "*" => Ok(a * b)
        _ => Err("unknown op")
    }
}

See Also

• Enums — define variants to match on
• Control Flow — if/else for simple conditions
• Error Handling — match on Result/Option