Struct Pattern 

pub struct Pattern<'ast> {
    pub data: PatternData<'ast>,
    pub alias: Option<LocIdent>,
    pub pos: TermPos,
}

A generic pattern, that can appear in a match expression (not yet implemented) or in a destructuring let-binding.

Fields

data: PatternData<'ast>

The content of this pattern

alias: Option<LocIdent>

A potential alias for this pattern, capturing the whole matched value. In the source language, an alias is introduced by x @ <pattern>, where x is an arbitrary identifier.

pos: TermPos

The position of the pattern in the source.

Implementations

impl Pattern<'_>

pub fn any(id: LocIdent) -> Self

Creates an Any pattern with the corresponding capture name.

pub fn try_as_any(&self) -> Option<LocIdent>

Returns Some(id) if this pattern is an PatternData::Any pattern, None otherwise.

Trait Implementations

impl<'ast> Bindings<'ast> for Pattern<'ast>

fn bindings(&self) -> Vec<PatBinding<'ast>>

Returns a list of all variables bound by this pattern, together with the path to the field they match and the associated extra annotations.

impl<'ast> Clone for Pattern<'ast>

fn clone(&self) -> Pattern<'ast>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl CloneTo for Pattern<'_>

type Data<'ast> = Pattern<'ast>

This is always Self, be we need associated types to make Rust understand that Self is always parametric over the 'ast lifetime. We’re using GATs to emulate higher-kinded types.

fn clone_to<'to>(pat: Pattern<'_>, dest: &'to AstAlloc) -> Pattern<'to>

Clones owned data from the current allocator to dest.

impl<'ast> Debug for Pattern<'ast>

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

Formats the value using the given formatter.

impl Display for Pattern<'_>

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

Formats the value using the given formatter.

impl<'ast> PartialEq for Pattern<'ast>

fn eq(&self, other: &Pattern<'ast>) -> 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<'a> Pretty<'a, Allocator> for &Pattern<'_>

fn pretty(self, allocator: &'a Allocator) -> DocBuilder<'a, Allocator>

Converts self into a document

impl<'ast> TraverseAlloc<'ast, Ast<'ast>> for Pattern<'ast>

fn traverse<F, E>( self, alloc: &'ast AstAlloc, f: &mut F, order: TraverseOrder, ) -> Result<Self, E>

where F: FnMut(Ast<'ast>) -> Result<Ast<'ast>, E>,

Same as Traverse::traverse, but takes an additional AST allocator.

fn traverse_ref<S, U>( &'ast self, f: &mut dyn FnMut(&'ast Ast<'ast>, &S) -> TraverseControl<S, U>, scope: &S, ) -> Option<U>

Same as Traverse::traverse_ref, but takes an additional AST allocator.

fn find_map<S>(&'ast self, pred: impl FnMut(&'ast T) -> Option<S>) -> Option<S>

where T: Clone + 'ast,

impl Allocable for Pattern<'_>

impl<'ast> Eq for Pattern<'ast>

impl<'ast> StructuralPartialEq for Pattern<'ast>