Enum Pat 

#[non_exhaustive]
pub enum Pat {
    Var {
        name: Identifier,
        pos: Pos,
        span: Span,
    },
    Wild {
        pos: Pos,
        span: Span,
    },
    Con {
        qualifier: Option<ModuleName>,
        name: Identifier,
        args: Vec<Self>,
        pos: Pos,
        span: Span,
    },
    Record {
        qualifier: Option<ModuleName>,
        name: Identifier,
        syntax: RecordPatternSyntax,
        fields: Vec<PatFieldAssign>,
        pos: Pos,
        span: Span,
    },
    Tuple {
        items: Vec<Self>,
        pos: Pos,
        span: Span,
    },
    List {
        items: Vec<Self>,
        pos: Pos,
        span: Span,
    },
    Lit {
        kind: LitKind,
        text: String,
        pos: Pos,
        span: Span,
    },
    As {
        name: Identifier,
        pat: Box<Self>,
        pos: Pos,
        span: Span,
    },
    Other {
        raw: String,
        pos: Pos,
        span: Span,
    },
}

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Var

Variable pattern.

Fields

name: Identifier

Bound variable name.

pos: Pos

Position of the variable token.

span: Span

Span of the variable token.

Wild

Wildcard pattern (_).

Fields

pos: Pos

Position of the _ token.

span: Span

Span of the _ token.

Con

Constructor pattern with source-ordered arguments.

Fields

qualifier: Option<ModuleName>

Optional module qualifier before the constructor name.

name: Identifier

Constructor name.

args: Vec<Self>

Constructor arguments in source order.

pos: Pos

Position of the constructor token.

span: Span

Span of the whole constructor pattern.

Record

Constructor record pattern with source-ordered fields.

Fields

qualifier: Option<ModuleName>

Optional module qualifier before the constructor name.

name: Identifier

Constructor name.

syntax: RecordPatternSyntax

Whether fields used {..} or with.

fields: Vec<PatFieldAssign>

Field patterns in source order.

pos: Pos

Position of the constructor token.

span: Span

Span of the whole record pattern.

Tuple

Tuple pattern with source-ordered items.

Fields

items: Vec<Self>

Tuple items in source order.

pos: Pos

Position of the opening parenthesis.

span: Span

Span from ( through ).

List

List pattern with source-ordered items.

Fields

items: Vec<Self>

List items in source order.

pos: Pos

Position of the opening bracket.

span: Span

Span from [ through ].

Lit

Literal pattern; text is the parser’s normalized literal text.

Fields

kind: LitKind

Literal family.

text: String

Normalized literal payload.

pos: Pos

Position of the literal token.

span: Span

Span of the literal token in the source.

As

name@pat

Fields

name: Identifier

Name bound to the whole matched pattern.

pat: Box<Self>

Pattern being aliased.

pos: Pos

Position of the bound name.

span: Span

Span of the whole name@pat pattern.

Other

Anything the parser couldn’t classify; raw text preserved.

Fields

raw: String

Raw source text of the unclassified pattern.

pos: Pos

Position of the raw pattern’s first token.

span: Span

Span of the preserved raw pattern text.

Implementations

impl Pat

pub const fn pos(&self) -> Pos

pub const fn span(&self) -> Span

Byte span covering the whole pattern.

pub fn render(&self) -> String

Render back to compact, source-like text. Lossy and normalizing in the same way as Expr::render; use the node’s span for byte-faithful text.

Trait Implementations

impl Clone for Pat

fn clone(&self) -> Pat

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Pat

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

Formats the value using the given formatter.

impl Display for Pat

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

Formats the value using the given formatter.

impl Eq for Pat

impl PartialEq for Pat

fn eq(&self, other: &Pat) -> 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 StructuralPartialEq for Pat