Pattern Matching

Pattern matching is a powerful feature in ReluxScript for working with AST nodes and data structures.

The matches! Macro

Check if a value matches a pattern:

// Simple name match
if matches!(node.callee, "console.log") {
    // Matched
}

// Operator match
if matches!(node.operator, "+") {
    // Addition operator
}

// Complex pattern
if matches!(node.callee, MemberExpression {
    object: Identifier { name: "console" },
    property: Identifier { name: "log" }
}) {
    // console.log()
}

Match Expression

Pattern match with multiple branches:

match node.operator {
    "+" => handle_addition(),
    "-" => handle_subtraction(),
    "*" | "/" => handle_mul_div(),
    _ => handle_other(),
}

With Values

let result = match node.type {
    "Identifier" => "id",
    "Literal" => "lit",
    _ => "other",
};

If-Let Pattern

Conditionally extract values:

if let Some(name) = get_identifier_name(node) {
    println!("Name: {}", name);
}

if let Ok(value) = parse_result {
    process(value);
}

Destructuring

Tuple Destructuring

let (x, y) = get_coordinates();
let (name, age, city) = person_info;

Struct Destructuring

match &node.callee {
    MemberExpression { object, property } => {
        // Use object and property
    }
    _ => {}
}

Pattern Types

Literal Patterns

match value {
    42 => "answer",
    0 => "zero",
    _ => "other",
}

Identifier Patterns

match node {
    Identifier { name } => println!("{}", name),
    _ => {},
}

Wildcard Pattern

match value {
    Some(x) => x,
    _ => default,  // Matches anything
}

Multiple Patterns

match op {
    "+" | "-" => "arithmetic",
    "*" | "/" | "%" => "multiplicative",
    _ => "other",
}

Advanced Patterns

Nested Patterns

match expr {
    CallExpression {
        callee: MemberExpression {
            object: Identifier { name: "console" }
        }
    } => {
        // console.method()
    }
    _ => {}
}

Guards (Coming Soon)

// Future feature
match value {
    Some(x) if x > 0 => "positive",
    Some(x) if x < 0 => "negative",
    Some(0) => "zero",
    None => "none",
}

Common Patterns

Check Node Type

if matches!(node, Expression::Identifier(_)) {
    // Is an identifier
}

Extract Optional Value

if let Some(arg) = node.argument {
    process(arg);
}

Handle Result

match parse_file(path) {
    Ok(ast) => process(ast),
    Err(msg) => eprintln!("Error: {}", msg),
}

Check Multiple Conditions

if matches!(node.callee, "useState") && node.type_args.is_some() {
    // useState<T>()
}

See Syntax Overview for more examples.