> ## 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. # Dart Logical-And Pattern The logical-and pattern (`&&`) is a composite pattern in Dart that matches a value if and only if both of its subpatterns successfully match the same value. It allows developers to apply multiple constraints, type checks, or destructuring operations to a single expression simultaneously. ## Syntax The pattern is constructed using the `&&` operator between two subpatterns: ```dart theme={"dark"} leftSubpattern && rightSubpattern ``` ## Evaluation Mechanics 1. **Shared Target:** Both `leftSubpattern` and `rightSubpattern` evaluate against the exact same matched value. 2. **Left-to-Right Execution:** The pattern evaluates the `leftSubpattern` first. 3. **Short-Circuiting:** If the `leftSubpattern` fails to match, the entire logical-and pattern fails immediately. The `rightSubpattern` is never evaluated. 4. **Success Condition:** The pattern as a whole succeeds only if the left subpattern succeeds *and* the right subpattern succeeds. ## Variable Binding Rules When using variable patterns within a logical-and pattern, the following strict scoping and binding rules apply: * **Union of Bindings:** The variables bound by the logical-and pattern are the union of the variables bound by both the left and right subpatterns. * **No Shadowing/Collisions:** It is a compile-time error if both subpatterns attempt to bind a variable with the exact same name. * **Scope Availability:** Variables bound in the left subpattern are not available for use within the right subpattern's evaluation logic, but all bound variables from both sides are exposed to the resulting case body if the entire pattern matches. ## Structural Examples **Combining a Type Test with a Relational Pattern** The left subpattern binds the value to a typed variable, while the right subpattern applies a relational constraint to the same value. ```dart theme={"dark"} switch (value) { case int x && >= 10: // Matches if 'value' is an integer AND is greater than or equal to 10. // 'x' is bound to the matched integer. break; } ``` **Multiple Destructuring on a Single Value** The logical-and pattern can extract different properties from the same object or record simultaneously by applying multiple object or record patterns. ```dart theme={"dark"} switch (pointRecord) { case (int x, _) && (_, int y): // Matches if the record has an integer in the first position AND an integer in the second. // Binds 'x' from the left subpattern and 'y' from the right subpattern. break; } ``` **Chaining Multiple Logical-And Patterns** The `&&` operator is left-associative and can be chained to enforce more than two constraints or extractions on the same value. When extracting properties from a class instance within a chain, an object pattern with an explicit type name must be used. ```dart theme={"dark"} if (value case List list && List(length: var len) && [_, var second, ...]) { // 1. Type test and variable binding: Checks if value is List and binds to 'list' // 2. Object pattern property extraction: Matches List, extracts the 'length' getter, and binds to 'len' // 3. List pattern destructuring: Ensures at least two elements and binds the second to 'second' } ```

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