Enum Pattern

pub enum Pattern {
    WildCard,
    Rest,
    Literal(Node<LiteralPattern>),
    Tuple(Vec<Node<Pattern>>),
    Path(Node<Path>),
    PathTuple(Node<Path>, Vec<Node<Pattern>>),
    PathStruct {
        path: Node<Path>,
        fields: Vec<(Node<SmolStr>, Node<Pattern>)>,
        has_rest: bool,
    },
    Or(Vec<Node<Pattern>>),
}

Variants

WildCard

Represents a wildcard pattern _.

Rest

Rest pattern. e.g., ..

Literal(Node<LiteralPattern>)

Represents a literal pattern. e.g., true.

Tuple(Vec<Node<Pattern>>)

Represents tuple destructuring pattern. e.g., (x, y, z).

Path(Node<Path>)

Represents unit variant pattern. e.g., Enum::Unit.

PathTuple(Node<Path>, Vec<Node<Pattern>>)

Represents tuple variant pattern. e.g., Enum::Tuple(x, y, z).

PathStruct

Represents struct or struct variant destructuring pattern. e.g., MyStruct {x: pat1, y: pat2}}.

Fields

path: Node<Path>

fields: Vec<(Node<SmolStr>, Node<Pattern>)>

has_rest: bool

Or(Vec<Node<Pattern>>)

Represents or pattern. e.g., EnumUnit | EnumTuple(_, _, _)

Implementations

impl Pattern

pub fn is_rest(&self) -> bool

Trait Implementations

impl Clone for Pattern

fn clone(&self) -> Pattern

Returns a copy 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 Display for Pattern

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

Formats the value using the given formatter.

impl Hash for Pattern

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

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