Enum Pat

#[non_exhaustive]
pub enum Pat

A pattern in a local binding, function signature, match expression, or various other places.

Syntax tree enum

This type is a syntax tree enum.

Variants

Const(PatConst)

A const block: const { ... }.

Guard(PatGuard)

A pattern with guard predicate: Some(x) if x > 0.

Ident(PatIdent)

A pattern that binds a new variable: ref mut binding @ SUBPATTERN.

Lit(PatLit)

A literal pattern: 0.

Macro(PatMacro)

A macro in pattern position.

Or(PatOr)

A pattern that matches any one of a set of cases.

Paren(PatParen)

A parenthesized pattern: (A | B).

Path(PatPath)

A path pattern like Color::Red, optionally qualified with a self-type.

Unqualified path patterns can legally refer to variants, structs, constants or associated constants. Qualified path patterns like <A>::B::C and <A as Trait>::B::C can only legally refer to associated constants.

Range(PatRange)

A range pattern: 1..=2.

Reference(PatReference)

A reference pattern: &mut var.

Rest(PatRest)

The dots in a tuple or slice pattern: [0, 1, ..].

Slice(PatSlice)

A dynamically sized slice pattern: [a, b, ref i @ .., y, z].

Struct(PatStruct)

A struct or struct variant pattern: Variant { x, y, .. }.

Tuple(PatTuple)

A tuple pattern: (a, b).

TupleStruct(PatTupleStruct)

A tuple struct or tuple variant pattern: Variant(x, y, .., z).

Type(PatType)

A type ascription pattern: foo: f64.

Verbatim(TokenStream)

Tokens in pattern position not interpreted by Syn.

Important: see [Compatibility notes][crate#verbatim-variants].

Wild(PatWild)

A pattern that matches any value: _.

Implementations

impl Pat

fn parse_single(input: ParseStream<'_>) -> Result<Self>

Parse a pattern that does not involve | at the top level.

This parser matches the behavior of the $:pat_param macro_rules matcher, and on editions prior to Rust 2021, the behavior of $:pat.

In Rust syntax, some examples of where this syntax would occur are in the argument pattern of functions and closures. Patterns using | are not allowed to occur in these positions.

fn f(Some(_) | None: Option<T>) {
    let _ = |Some(_) | None: Option<T>| {};
    //       ^^^^^^^^^^^^^^^^^^^^^^^^^??? :(
}

error: top-level or-patterns are not allowed in function parameters
 --> src/main.rs:1:6
  |
1 | fn f(Some(_) | None: Option<T>) {
  |      ^^^^^^^^^^^^^^ help: wrap the pattern in parentheses: `(Some(_) | None)`

fn parse_multi(input: ParseStream<'_>) -> Result<Self>

Parse a pattern, possibly involving |, but not a leading |.

fn parse_multi_with_leading_vert(input: ParseStream<'_>) -> Result<Self>

Parse a pattern, possibly involving |, possibly including a leading |.

This parser matches the behavior of the Rust 2021 edition's $:pat macro_rules matcher.

In Rust syntax, an example of where this syntax would occur is in the pattern of a match arm, where the language permits an optional leading |, although it is not idiomatic to write one there in handwritten code.

# let wat = None;
match wat {
    | None | Some(false) => {}
    | Some(true) => {}
}

The compiler accepts it only to facilitate some situations in macro-generated code where a macro author might need to write:

# macro_rules! doc {
#     ($value:expr, ($($conditions1:pat),*), ($($conditions2:pat),*), $then:expr) => {
match $value {
    $(| $conditions1)* $(| $conditions2)* => $then
}
#     };
# }
#
# doc!(true, (true), (false), {});
# doc!(true, (), (true, false), {});
# doc!(true, (true, false), (), {});

Expressing the same thing correctly in the case that either one (but not both) of $conditions1 and $conditions2 might be empty, without leading |, is complex.

Use Pat::parse_multi instead if you are not intending to support macro-generated macro input.

Trait Implementations

impl Clone for Pat

fn clone(&self) -> Self

impl ToTokens for Pat

fn to_tokens(&self, tokens: &mut TokenStream)

Auto Trait Implementations

impl !Send for Pat

impl !Sync for Pat

impl Freeze for Pat

impl RefUnwindSafe for Pat

impl Unpin for Pat

impl UnsafeUnpin for Pat

impl UnwindSafe for Pat

Blanket Implementations

impl<T> Any for Pat where T: 'static + ?Sized,

fn type_id(&self) -> TypeId

impl<T> Borrow<T> for Pat where T: ?Sized,

fn borrow(&self) -> &T

impl<T> BorrowMut<T> for Pat where T: ?Sized,

fn borrow_mut(&mut self) -> &mut T

impl<T> CloneToUninit for Pat where T: Clone,

unsafe fn clone_to_uninit(&self, dest: *mut u8)

impl<T> From<T> for Pat

fn from(t: T) -> T

Returns the argument unchanged.

impl<T> Spanned for Pat where T: Spanned + ?Sized,

fn span(&self) -> Span

impl<T> ToOwned for Pat where T: Clone,

type Owned = T;
fn to_owned(&self) -> T
fn clone_into(&self, target: &mut T)

impl<T, U> Into<U> for Pat where U: From<T>,

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

impl<T, U> TryFrom<U> for Pat where U: Into<T>,

type Error = never;
fn try_from(value: U) -> Result<T, never>

impl<T, U> TryInto<U> for Pat where U: TryFrom<T>,

type Error = <U as TryFrom<T>>::Error;
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>