Skip to main content

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.

A parenthesized pattern is a pattern enclosed in parentheses that delegates its matching behavior entirely to its inner subpattern. It is utilized strictly to control pattern binding, group subpatterns in the Abstract Syntax Tree (AST), and resolve syntactic ambiguities within complex pattern-matching expressions.

​
Syntax

( <pattern> )

​
Mechanics

  • Transparent Matching: A parenthesized pattern matches a value if and only if the inner <pattern> matches that value. It does not introduce any new matching logic, type checking, or destructuring behavior.
  • Binding and Grouping: Dart patterns follow a strict binding precedence. For example, postfix patterns (as, !, ?) bind tighter than logical AND (&&), which binds tighter than logical OR (||). Parentheses alter this AST grouping, allowing a postfix pattern to apply to an entire logical pattern group rather than just the adjacent operand.
  • Outside-In Matching: In Dart, pattern matching flows from the outside in. Parentheses define the inner pattern. When a parenthesized pattern is combined with an outer postfix pattern, the value is processed by the outer pattern first, and the result is then passed inward to the parenthesized subpattern.

​
Syntax Visualization

1. Controlling Logical Binding By default, logical AND (&&) binds tighter than logical OR (||). Parenthesized patterns alter this grouping. 
switch (number) {
  // Binds as: (match > 0 AND match < 10) OR match == 20
  case > 0 && < 10 || == 20: 
    break;

  // Binds as: match > 0 AND (match < 10 OR match == 20)
  case > 0 && (< 10 || == 20): 
    break;
}
2. Controlling Postfix Binding Postfix patterns like type casting (as) or null-asserts (!) have higher precedence than logical patterns. Parentheses are required to apply a postfix pattern to an entire logical group. Because patterns match outside-in, the postfix operation becomes the outer pattern. 
switch (value) {
  // Without parentheses, `as int` binds only to `2`.
  // Grouping: 1 || (2 as int)
  case 1 || 2 as int:
    break;

  // With parentheses, `as int` becomes the outer pattern.
  // The value is cast to `int` first, then passed inward to match `1 || 2`.
  case (1 || 2) as int:
    break;
    
  // `!` becomes the outer pattern. 
  // The value is null-asserted first, then passed inward to match `3 || 4`.
  case (3 || 4)!:
    break;
}

​
Disambiguation from Record Patterns

Because both parenthesized patterns and record patterns utilize parentheses, Dart differentiates them syntactically based on the presence of a trailing comma or multiple elements. 
switch (value) {
  // Parenthesized pattern (contains exactly one subpattern, no trailing comma)
  case ('a'): 
    break;

  // Record pattern (contains one subpattern WITH a trailing comma)
  case ('a',): 
    break;

  // Record pattern (contains multiple subpatterns)
  case ('a', 'b'): 
    break;
}
Master Dart with Deep Grasping Methodology!Learn More