Enum Pattern 

pub enum Pattern {
    Wild(Span),
    Value(Expr),
    Let(Name),
    Type {
        ty: Type,
        bind: Option<Name>,
    },
    Variant {
        path: Vec<Name>,
        args: Vec<Pattern>,
    },
    Relational {
        op: BinOp,
        value: Expr,
    },
    Range {
        from: Expr,
        to: Expr,
    },
    Tuple(Vec<Pattern>),
    List(Vec<Pattern>, Span),
    Slice(Option<Box<Pattern>>),
    Property {
        ty: Option<Type>,
        fields: Vec<(Name, Pattern)>,
    },
    Or(Box<Pattern>, Box<Pattern>),
    And(Box<Pattern>, Box<Pattern>),
    Not(Box<Pattern>),
}

Variants

Wild(Span)

Value(Expr)

A literal or a path to a value or a case (0, Mode.Idle); a lone path may be a type too: the resolver and the checker tell.

Let(Name)

let e.

Type

Monster m, Monster.

Fields

ty: Type

bind: Option<Name>

Variant

Mode.Charging(let rate).

Fields

path: Vec<Name>

args: Vec<Pattern>

Relational

< 5.

Fields

op: BinOp

value: Expr

Range

Fields

from: Expr

to: Expr

Tuple(Vec<Pattern>)

List(Vec<Pattern>, Span)

[1, let second, .., let last] (C#’s list pattern): an array’s, a string’s or a list’s items, a .. among them at most once.

Slice(Option<Box<Pattern>>)

.. in a list pattern: the items it doesn’t name, .. let rest matching them as a slice.

Property

{ Health: < 5 }, Monster { Health: < 5 }.

Fields

ty: Option<Type>

fields: Vec<(Name, Pattern)>

Or(Box<Pattern>, Box<Pattern>)

And(Box<Pattern>, Box<Pattern>)

Not(Box<Pattern>)

Implementations

impl Pattern

pub fn each_binding<'p>(&'p self, f: &mut impl FnMut(&'p Name))

The names the pattern binds (let e, Monster m), in order.

Trait Implementations

impl Clone for Pattern

fn clone(&self) -> Self

Returns a duplicate 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: &Self) -> bool

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Pattern