Enum PurePattern 

pub enum PurePattern {
    Ident {
        name: String,
        is_mut: bool,
    },
    Wild,
    Tuple(Vec<PurePattern>),
    Struct {
        path: String,
        fields: Vec<(String, PurePattern)>,
        rest: bool,
    },
    Ref {
        is_mut: bool,
        pattern: Box<PurePattern>,
    },
    Lit(String),
    Or(Vec<PurePattern>),
    Path(String),
    Range {
        start: Option<String>,
        end: Option<String>,
        inclusive: bool,
    },
    Slice(Vec<PurePattern>),
    Rest,
    Other(String),
}

A pattern.

Variants

Ident

Identifier: x, mut x

Fields

name: String

Binding name.

is_mut: bool

mut qualifier.

Wild

Wildcard: _

Tuple(Vec<PurePattern>)

Tuple: (a, b)

Struct

Struct: Point { x, y } or Point { x, .. }

Fields

path: String

Struct path (e.g. Point).

fields: Vec<(String, PurePattern)>

Field bindings (name, sub-pattern).

rest: bool

Whether the pattern has a rest (..) at the end

Ref

Reference: &x, &mut x

Fields

is_mut: bool

mut qualifier (&mut).

pattern: Box<PurePattern>

Inner pattern after & / &mut.

Lit(String)

Literal (for matching).

Or(Vec<PurePattern>)

Or pattern: A | B

Path(String)

Path pattern: Some, None, Enum::Variant

Range

Range pattern: 1..=5, 'a'..='z'

Fields

start: Option<String>

Start literal (None = unbounded below).

end: Option<String>

End literal (None = unbounded above).

inclusive: bool

..= (inclusive) vs .. (exclusive).

Slice(Vec<PurePattern>)

Slice pattern: [a, b, ..]

Rest

Rest pattern: ..

Other(String)

Other (as string) - unsupported patterns with error guidance.

Trait Implementations

impl Clone for PurePattern

fn clone(&self) -> PurePattern

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PurePattern

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

Formats the value using the given formatter.

impl PartialEq for PurePattern

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

type Output = Pat

syn output type produced from self.

fn to_syn(&self) -> Result<Pat, ToSynError>

Convert self back into its syn representation.

impl Eq for PurePattern

impl StructuralPartialEq for PurePattern