Enum syntex_syntax::ast::PatKind

pub enum PatKind {
    Wild,
    Ident(BindingMode, SpannedIdent, Option<P<Pat>>),
    Struct(Path, Vec<Spanned<FieldPat>>, bool),
    TupleStruct(Path, Option<Vec<P<Pat>>>),
    Path(Path),
    QPath(QSelf, Path),
    Tup(Vec<P<Pat>>),
    Box(P<Pat>),
    Ref(P<Pat>, Mutability),
    Lit(P<Expr>),
    Range(P<Expr>, P<Expr>),
    Vec(Vec<P<Pat>>, Option<P<Pat>>, Vec<P<Pat>>),
    Mac(Mac),
}

Variants

Wild

Represents a wildcard pattern (_)

Ident(BindingMode, SpannedIdent, Option<P<Pat>>)

A PatKind::Ident may either be a new bound variable, or a unit struct/variant pattern, or a const pattern (in the last two cases the third field must be None).

In the unit or const pattern case, the parser can't determine which it is. The resolver determines this, and records this pattern's NodeId in an auxiliary set (of "PatIdents that refer to unit patterns or constants").

Struct(Path, Vec<Spanned<FieldPat>>, bool)

A struct or struct variant pattern, e.g. Variant {x, y, ..}. The bool is true in the presence of a ...

TupleStruct(Path, Option<Vec<P<Pat>>>)

A tuple struct/variant pattern Variant(x, y, z). "None" means a Variant(..) pattern where we don't bind the fields to names.

Path(Path)

A path pattern. Such pattern can be resolved to a unit struct/variant or a constant.

QPath(QSelf, Path)

An associated const named using the qualified path <T>::CONST or <T as Trait>::CONST. Associated consts from inherent impls can be referred to as simply T::CONST, in which case they will end up as PatKind::Path, and the resolver will have to sort that out.

Tup(Vec<P<Pat>>)

A tuple pattern (a, b)

Box(P<Pat>)

A box pattern

Ref(P<Pat>, Mutability)

A reference pattern, e.g. &mut (a, b)

Lit(P<Expr>)

A literal

Range(P<Expr>, P<Expr>)

A range pattern, e.g. 1...2

Vec(Vec<P<Pat>>, Option<P<Pat>>, Vec<P<Pat>>)

[a, b, ..i, y, z] is represented as: PatKind::Vec(box [a, b], Some(i), box [y, z])

Mac(Mac)

A macro pattern; pre-expansion

Trait Implementations

impl Debug for PatKind

fn fmt(&self, __arg_0: &mut Formatter) -> Result

Formats the value using the given formatter.

impl Hash for PatKind

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

Feeds this value into the state given, updating the hasher as necessary.

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

Feeds a slice of this type into the state provided.

impl Decodable for PatKind

fn decode<__D: Decoder>(__arg_0: &mut __D) -> Result<PatKind, __D::Error>

impl Encodable for PatKind

fn encode<__S: Encoder>(&self, __arg_0: &mut __S) -> Result<(), __S::Error>

impl Eq for PatKind

impl PartialEq for PatKind

fn eq(&self, __arg_0: &PatKind) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, __arg_0: &PatKind) -> bool

This method tests for !=.

impl Clone for PatKind

fn clone(&self) -> PatKind

Returns a copy of the value.

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

Performs copy-assignment from source.