Enum cairo_lang_semantic::expr::pattern::Pattern

pub enum Pattern {
    Literal(PatternLiteral),
    Variable(PatternVariable),
    Struct(PatternStruct),
    Tuple(PatternTuple),
    EnumVariant(PatternEnumVariant),
    Otherwise(PatternOtherwise),
}

Semantic representation of a Pattern. A pattern is a way to “destructure” values. A pattern may introduce new variables that are bound to inner values of a specific value. For example, a tuple pattern destructures a tuple and may result in new variables for an elements of that tuple. This is used both in let statements and match statements.

Variants

Literal(PatternLiteral)

Variable(PatternVariable)

Struct(PatternStruct)

Tuple(PatternTuple)

EnumVariant(PatternEnumVariant)

Otherwise(PatternOtherwise)

Implementations

impl Pattern

pub fn ty(&self, _db: &dyn SemanticGroup) -> TypeId

pub fn variables(&self) -> Vec<&PatternVariable>

pub fn stable_ptr(&self) -> PatternPtr

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<'a, T: ?Sized + Upcast<ExprFormatter<'a>>> DebugWithDb<T> for Pattern

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

fn debug<'me, 'db>(&'me self, db: &'me Db) -> DebugWith<'me, Db>where Self: Sized + 'me,

fn into_debug<'me, 'db>(self, db: &'me Db) -> DebugWith<'me, Db>where Self: Sized + 'me,

impl Hash for Pattern

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

Feeds this value into the given Hasher.

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

Feeds a slice of this type into the given Hasher.

impl PartialEq for Pattern

fn eq(&self, other: &Pattern) -> bool

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

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: SemanticRewriter<PatternLiteral, Error> + SemanticRewriter<PatternVariable, Error> + SemanticRewriter<PatternStruct, Error> + SemanticRewriter<PatternTuple, Error> + SemanticRewriter<PatternEnumVariant, Error> + SemanticRewriter<PatternOtherwise, Error>, Error> SemanticObject<T, Error> for Pattern

fn default_rewrite(self, rewriter: &mut T) -> Result<Self, Error>

impl<'a> SemanticRewriter<Pattern, NoError> for Inference<'a>

fn rewrite(&mut self, value: Pattern) -> Result<Pattern, NoError>

impl Eq for Pattern

impl StructuralEq for Pattern

impl StructuralPartialEq for Pattern