Enum Pattern 

pub enum Pattern {
    Wildcard(Span),
    Binding(Ident),
    Literal {
        value: LiteralValue,
        span: Span,
    },
    Variant {
        type_name: Option<Ident>,
        variant: Ident,
        bindings: Vec<PatternBinding>,
        span: Span,
    },
    Refined {
        inner: Box<Pattern>,
        predicate: Refinement,
        span: Span,
    },
    Or(Vec<Pattern>, Span),
}

A pattern (v0.2 §3.8). Patterns appear in match arms and as the right-hand side of the is operator.

Variants

Wildcard(Span)

_ — matches any value, no bindings.

Binding(Ident)

A lowercase identifier — binds the whole value to name and matches anything (ADR 0169). At the top of a match arm it binds the scrutinee (n if n > 0 => …); inside a payload position it binds the field (Some(user)). The uppercase-led counterpart is a nullary Pattern::Variant.

Literal

A literal pattern — 31, "english", true (v0.130 §2.3.4). Matches a primitive scrutinee (Int/String/Bool) by value equality. The admitted set mirrors ADR 0001’s closed literal set (integers — including a leading unary minus — strings, and booleans); Float/() are not admitted as patterns.

Fields

value: LiteralValue

span: Span

Variant

Variant or Variant(bindings) or TypeName.Variant(bindings). Each payload binding is itself a Pattern (ADR 0169), so payloads nest: Some(Ok(x)), Err(PollClosed).

Fields

type_name: Option<Ident>

Optional qualifier: TypeName.Variant.

variant: Ident

The variant name.

bindings: Vec<PatternBinding>

Payload bindings (empty for nullary variants).

span: Span

Refined

p 'where' refinement-predicate — a refinement guard on a pattern (#472). Matches when inner matches and the scrutinee satisfies predicate at runtime. v1 admits only Wildcard as inner (no binding form yet); refutable — never counts toward exhaustiveness or as a catch-all arm, the same treatment as an if guard (§2.3.4).

Fields

inner: Box<Pattern>

predicate: Refinement

span: Span

Or(Vec<Pattern>, Span)

p₁ | p₂ | … | pₙ — an or-pattern (#474 §2.3.4): matches if any alternative matches. Left-associative |, flattened by the parser’s chain fold into one Vec — an alternative is always a leaf (Wildcard/Binding/Literal/Variant), never itself an Or (there is no parenthesized-pattern syntax to nest one inside another). Well-typedness (checked, not parsed): every alternative binds the same set of names, a name shared across alternatives has the same type (including refinement) in each, and every alternative matches the same value type.

Implementations

impl Pattern

pub fn span(&self) -> Span

pub fn bound_names(&self) -> Vec<&Ident>

Every identifier this pattern binds into scope, recursively (_ and nullary variants bind nothing). Used by the resolver and the checker to populate an arm’s scope, and by the guard to see the arm’s bindings.

For Pattern::Or this returns the first alternative’s names — the checker separately verifies (#474 Rule 1) that every alternative binds the same set, so this is a defensive default when that rule is violated, not a semantic choice among alternatives.

pub fn is_wildcard(&self) -> bool

True when this pattern matches every value and binds nothing — a bare _. A Pattern::Binding also matches everything but does bind, so it is not a pure wildcard.

pub fn is_irrefutable(&self) -> bool

True when this pattern matches every value (a _ or a name binding), i.e. it is irrefutable and covers the position for exhaustiveness. An Pattern::Or is irrefutable when any alternative is — _ in any position already makes the whole pattern match everything.

Trait Implementations

impl Clone for Pattern

fn clone(&self) -> Pattern

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Pattern

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.