Enum Pattern 

pub enum Pattern {
    Wildcard(Span),
    Ident {
        is_mut: bool,
        name: Ident,
        span: Span,
    },
    Int(IntLit),
    NegInt(NegIntLit),
    Bool(BoolLit),
    Path(PathPattern),
    DataVariant {
        base: Option<Box<Expr>>,
        type_name: Ident,
        variant: Ident,
        fields: Vec<TupleElemPattern>,
        span: Span,
    },
    StructVariant {
        base: Option<Box<Expr>>,
        type_name: Ident,
        variant: Ident,
        fields: Vec<FieldPattern>,
        span: Span,
    },
    Struct {
        type_name: Ident,
        fields: Vec<FieldPattern>,
        span: Span,
    },
    Tuple {
        elems: Vec<TupleElemPattern>,
        span: Span,
    },
    ComptimeUnrollArm {
        binding: Ident,
        iterable: Box<Expr>,
        span: Span,
    },
}

A pattern in a let binding or match arm (ADR-0049).

A single recursive Pattern type is used in both contexts. Sema enforces refutability per context (let requires irrefutable patterns, match accepts any).

Variants

Wildcard(Span)

Wildcard pattern _ - matches anything, irrefutable

Ident

Named binding (x or mut x), irrefutable

Fields

is_mut: bool

name: Ident

span: Span

Int(IntLit)

Integer literal pattern (positive or zero), refutable

NegInt(NegIntLit)

Negative integer literal pattern (e.g., -1, -42), refutable

Bool(BoolLit)

Boolean literal pattern, refutable

Path(PathPattern)

Path pattern (e.g., Color::Red for a unit enum variant), refutable

DataVariant

Data variant pattern with positional sub-patterns (e.g., Option::Some(x))

Fields

base: Option<Box<Expr>>

Optional module prefix

type_name: Ident

Enum type name

variant: Ident

Variant name

fields: Vec<TupleElemPattern>

Sub-patterns for each field (may include .. via TupleElemPattern::Rest)

span: Span

StructVariant

Struct variant pattern with named field sub-patterns (e.g., Shape::Circle { radius })

Fields

base: Option<Box<Expr>>

Optional module prefix

type_name: Ident

Enum type name

variant: Ident

Variant name

fields: Vec<FieldPattern>

Named field sub-patterns (may include .. via a field with field_name: None)

span: Span

Struct

Struct destructure pattern (e.g., Point { x, y }), irrefutable when all sub-patterns are.

Fields

type_name: Ident

The struct type name (for anonymous structs, resolved via a local type alias)

fields: Vec<FieldPattern>

Named field sub-patterns (may include ..)

span: Span

Tuple

Tuple destructure pattern (e.g., (a, b) or (a, .., c)), irrefutable when all sub-patterns are.

Fields

elems: Vec<TupleElemPattern>

span: Span

ComptimeUnrollArm

ADR-0079 Phase 3: a comptime_unroll for arm template. Only valid at the top level of a match arm — sema rejects it elsewhere. The arm fires once per element of iterable; the compiler synthesizes a variant-specific concrete pattern per iteration and substitutes binding as a comptime value in the arm body.

Fields

binding: Ident

iterable: Box<Expr>

span: Span

Implementations

impl Pattern

pub fn span(&self) -> Span

Get the span of this pattern.

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.

impl<'de> Deserialize<'de> for Pattern

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Pattern

fn eq(&self, other: &Pattern) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Pattern

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for Pattern

impl StructuralPartialEq for Pattern