> ## Documentation Index > Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt > Use this file to discover all available pages before exploring further. # Rust Or Pattern An Or pattern in Rust is a structural matching construct denoted by the pipe operator (`|`) that allows a single pattern-matching arm to evaluate against multiple alternative patterns. If the scrutinized value matches any of the specified alternatives, the overall pattern match succeeds. ```rust theme={"dark"} pattern_1 | pattern_2 | ... | pattern_n => expression, ``` ## Core Mechanics and Evaluation Or patterns evaluate strictly from left to right. The compiler utilizes short-circuit evaluation; the first alternative that successfully matches the scrutinized value terminates the pattern evaluation, and the associated code block is executed. While Or patterns are valid in any pattern-matching context (including `match`, `if let`, and `while let`), their use in `let` statements and function parameters carries a strict irrefutability requirement. Because `let` bindings and function parameters cannot handle match failures, the Or pattern used in these contexts must be *irrefutable* (guaranteed to match all possible values of the type). Most Or patterns, such as matching specific integers, are refutable and will cause a compile-time error in these contexts. ```rust theme={"dark"} let x = 2; // Refutable context: match expression match x { 1 | 2 | 3 => println!("Matched 1, 2, or 3"), _ => println!("Matched something else"), } // Refutable context: if let expression if let 4 | 5 = x { println!("Matched 4 or 5"); } // Irrefutable context: let statement // VALID: The Or pattern exhaustively covers both variants of Result let Ok(val) | Err(val) = Result::::Ok(10); // INVALID: Refutable pattern in a let statement causes a compile-time error // let 1 | 2 = x; ``` ## Variable Binding Uniformity The most strict compiler constraint regarding Or patterns is **binding uniformity**. If an Or pattern binds variables to extract data from the scrutinized value, every alternative within that Or pattern must bind the exact same set of variables. Furthermore, the bound variables must resolve to the exact same type *and* utilize the exact same binding mode (`mut`, `ref`, `ref mut`, or by value) across all alternatives. ```rust theme={"dark"} enum Node { Leaf(i32), Branch(i32, i32), } let node = Node::Leaf(5); match node { // VALID: `val` is bound in both alternatives, is of type `i32` in both, // and is bound by value in both. Node::Leaf(val) | Node::Branch(val, _) => println!("Value: {}", val), } ``` Violating these constraints results in specific compile-time errors: * Failing to bind the same variables yields `E0408: variable is not bound in all patterns`. * Using different binding modes yields `E0409: variable is bound inconsistently`. ```rust theme={"dark"} let opt = Some(10); match opt { // INVALID (E0408): `x` is bound in the first alternative, but not the second. // Some(x) | None => println!("Value"), // INVALID (E0409): `x` is bound by value in the first alternative, // but by `mut` in the second alternative. // Some(x) | Some(mut x) => println!("Value"), _ => () } ``` ## Nested Or Patterns Or patterns can be nested arbitrarily deep within other structural patterns (such as tuples, slices, structs, or enum variants). You do not need to duplicate the outer structure to match against multiple inner values. ```rust theme={"dark"} let result: Result, &str> = Ok(Some(42)); match result { // The Or pattern (1 | 2 | 42) is nested inside the Option, // which is nested inside the Result. Ok(Some(1 | 2 | 42)) => println!("Matched specific inner values"), Ok(None) | Err(_) => println!("Matched other states"), _ => () } ``` ## Precedence and Grouping The `|` operator has low precedence in pattern syntax. When combining Or patterns with other pattern features, such as range patterns (`..=`) or reference modifiers (`&`, `ref`), the Or pattern applies to the entire pattern on either side of the pipe. Parentheses must be used to explicitly group Or patterns to control precedence and restrict the scope of the alternation. ```rust theme={"dark"} let reference = &1; match reference { // VALID: Parentheses group the Or pattern. // This matches a reference to `0` OR a reference to `1`. &(0 | 1) => println!("Matched a reference to 0 or 1"), // INVALID PRECEDENCE: Without parentheses, `&0 | 1` is parsed as: // (&0) | (1) // This attempts to match either a reference to 0, or the integer 1. // This causes a type mismatch error because the alternatives have different types. // &0 | 1 => println!("Will not compile"), _ => () } ```

Tired of Poor Rust Skills? Fix That With Deep Grasping! Learn More