Enum Pattern

pub enum Pattern {
    BindPattern(TypeId, VarId, Box<Pattern>),
    Var(TypeId, VarId),
    ConstInt(TypeId, i128),
    ConstPrim(TypeId, Sym),
    Term(TypeId, TermId, Vec<Pattern>),
    Wildcard(TypeId),
    And(TypeId, Vec<Pattern>),
}

A left-hand side pattern of some rule.

Variants

BindPattern(TypeId, VarId, Box<Pattern>)

Bind a variable of the given type from the current value.

Keep matching on the value with the subpattern.

Var(TypeId, VarId)

Match the current value against an already bound variable with the given type.

ConstInt(TypeId, i128)

Match the current value against a constant integer of the given integer type.

ConstPrim(TypeId, Sym)

Match the current value against a constant primitive value of the given primitive type.

Term(TypeId, TermId, Vec<Pattern>)

Match the current value against the given extractor term with the given arguments.

Wildcard(TypeId)

Match anything of the given type successfully.

And(TypeId, Vec<Pattern>)

Match all of the following patterns of the given type.

Implementations

impl Pattern

pub fn ty(&self) -> TypeId

Get this pattern’s type.

pub fn visit<V: PatternVisitor>( &self, visitor: &mut V, input: V::PatternId, termenv: &TermEnv, vars: &mut HashMap<VarId, V::PatternId>, )

Recursively visit every sub-pattern.

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 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 Eq for Pattern

impl StructuralPartialEq for Pattern