Enum PatKind

pub enum PatKind<'hir> {
    Wild,
    Binding(BindingMode, HirId, Ident, Option<&'hir Pat<'hir>>),
    Struct(QPath<'hir>, &'hir [PatField<'hir>], bool),
    TupleStruct(QPath<'hir>, &'hir [Pat<'hir>], DotDotPos),
    Or(&'hir [Pat<'hir>]),
    Never,
    Path(QPath<'hir>),
    Tuple(&'hir [Pat<'hir>], DotDotPos),
    Box(&'hir Pat<'hir>),
    Deref(&'hir Pat<'hir>),
    Ref(&'hir Pat<'hir>, Mutability),
    Lit(&'hir Expr<'hir>),
    Range(Option<&'hir Expr<'hir>>, Option<&'hir Expr<'hir>>, RangeEnd),
    Slice(&'hir [Pat<'hir>], Option<&'hir Pat<'hir>>, &'hir [Pat<'hir>]),
    Err(ErrorGuaranteed),
}

Variants

Wild

Represents a wildcard pattern (i.e., _).

Binding(BindingMode, HirId, Ident, Option<&'hir Pat<'hir>>)

A fresh binding ref mut binding @ OPT_SUBPATTERN. The HirId is the canonical ID for the variable being bound, (e.g., in Ok(x) | Err(x), both x use the same canonical ID), which is the pattern ID of the first x.

Struct(QPath<'hir>, &'hir [PatField<'hir>], bool)

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

TupleStruct(QPath<'hir>, &'hir [Pat<'hir>], DotDotPos)

A tuple struct/variant pattern Variant(x, y, .., z). If the .. pattern fragment is present, then DotDotPos denotes its position. 0 <= position <= subpats.len()

Or(&'hir [Pat<'hir>])

An or-pattern A | B | C. Invariant: pats.len() >= 2.

Never

A never pattern !.

Path(QPath<'hir>)

A path pattern for a unit struct/variant or a (maybe-associated) constant.

Tuple(&'hir [Pat<'hir>], DotDotPos)

A tuple pattern (e.g., (a, b)). If the .. pattern fragment is present, then Option<usize> denotes its position. 0 <= position <= subpats.len()

Box(&'hir Pat<'hir>)

A box pattern.

Deref(&'hir Pat<'hir>)

A deref pattern (currently deref!() macro-based syntax).

Ref(&'hir Pat<'hir>, Mutability)

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

Lit(&'hir Expr<'hir>)

A literal.

Range(Option<&'hir Expr<'hir>>, Option<&'hir Expr<'hir>>, RangeEnd)

A range pattern (e.g., 1..=2 or 1..2).

Slice(&'hir [Pat<'hir>], Option<&'hir Pat<'hir>>, &'hir [Pat<'hir>])

A slice pattern, [before_0, ..., before_n, (slice, after_0, ..., after_n)?].

Here, slice is lowered from the syntax ($binding_mode $ident @)? ... If slice exists, then after can be non-empty.

The representation for e.g., [a, b, .., c, d] is:

PatKind::Slice([Binding(a), Binding(b)], Some(Wild), [Binding(c), Binding(d)])

Err(ErrorGuaranteed)

A placeholder for a pattern that wasn’t well formed in some way.

Trait Implementations

impl<'hir> Clone for PatKind<'hir>

fn clone(&self) -> PatKind<'hir>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'hir> Debug for PatKind<'hir>

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

Formats the value using the given formatter.

impl<'hir, __CTX> HashStable<__CTX> for PatKind<'hir>

where __CTX: HashStableContext,

fn hash_stable(&self, __hcx: &mut __CTX, __hasher: &mut StableHasher)

impl<'hir> Copy for PatKind<'hir>

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 48 bytes

Size for each variant:

• Wild: 0 bytes
• Binding: 31 bytes
• Struct: 47 bytes
• TupleStruct: 47 bytes
• Or: 23 bytes
• Never: 0 bytes
• Path: 31 bytes
• Tuple: 23 bytes
• Box: 15 bytes
• Deref: 15 bytes
• Ref: 15 bytes
• Lit: 15 bytes
• Range: 23 bytes
• Slice: 47 bytes
• Err: 0 bytes