Enum Pattern

pub enum Pattern {
    Literal(PatternLiteral),
    StringLiteral(PatternStringLiteral),
    Variable(PatternVariable),
    Struct(PatternStruct),
    Tuple(PatternTuple),
    FixedSizeArray(PatternFixedSizeArray),
    EnumVariant(PatternEnumVariant),
    Otherwise(PatternOtherwise),
    Missing(PatternMissing),
}

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)

StringLiteral(PatternStringLiteral)

Variable(PatternVariable)

Struct(PatternStruct)

Tuple(PatternTuple)

FixedSizeArray(PatternFixedSizeArray)

EnumVariant(PatternEnumVariant)

Otherwise(PatternOtherwise)

Missing(PatternMissing)

Implementations

impl Pattern

pub fn ty(&self) -> TypeId

pub fn variables( &self, queryable: &dyn PatternVariablesQueryable, ) -> 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 From<&Pattern> for SyntaxStablePtrId

fn from(pattern: &Pattern) -> Self

Converts to this type from the input type.

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<T: SemanticRewriter<PatternLiteral, Error> + SemanticRewriter<PatternStringLiteral, Error> + SemanticRewriter<PatternVariable, Error> + SemanticRewriter<PatternStruct, Error> + SemanticRewriter<PatternTuple, Error> + SemanticRewriter<PatternFixedSizeArray, Error> + SemanticRewriter<PatternEnumVariant, Error> + SemanticRewriter<PatternOtherwise, Error> + SemanticRewriter<PatternMissing, Error>, Error> SemanticObject<T, Error> for Pattern

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

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

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

fn rewrite(&mut self, value: T) -> Result<T, Error>

impl Eq for Pattern

impl StructuralPartialEq for Pattern