Enum Pattern 

pub enum Pattern {
    Variant {
        name: String,
        sub: Vec<Pattern>,
        span: Span,
    },
    Wildcard {
        span: Span,
    },
    Binding {
        name: String,
        span: Span,
    },
    Int {
        value: i64,
        span: Span,
    },
    Float {
        value: f64,
        span: Span,
    },
    Byte {
        value: u8,
        span: Span,
    },
    Str {
        value: String,
        span: Span,
    },
    Bool {
        value: bool,
        span: Span,
    },
}

a pattern in a match arm. v1 has variant destructure (with sub-patterns), the _ wildcard, a name binding, and literal patterns; no or-patterns, no struct patterns, no nested guards (guards live on the MatchArm).

Variants

Variant

Name(sub, ...) – destructure an enum variant; sub is the sub-patterns for its fields (empty for a no-data variant matched as Name). whether Name is a real variant is Phase 3’s call.

Fields

name: String

sub: Vec<Pattern>

span: Span

Wildcard

_ – matches anything, binds nothing.

Fields

span: Span

Binding

name – matches anything, binds it to name.

Fields

name: String

span: Span

Int

an integer literal pattern.

Fields

value: i64

span: Span

Float

a float literal pattern.

Fields

value: f64

span: Span

Byte

a byte literal pattern.

Fields

value: u8

span: Span

Str

a string literal pattern.

Fields

value: String

span: Span

Bool

a boolean literal pattern, true or false.

Fields

value: bool

span: Span

Implementations

impl Pattern

pub fn span(&self) -> Span

the source span of this pattern.

every variant carries its span field; the match is exhaustive, the proof every pattern has one.

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 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 StructuralPartialEq for Pattern