Enum Pattern 

pub enum Pattern {
    Discard,
    Bind(Text),
    At(Text, Box<Pattern>),
    Equal(Expr),
    Less(Expr),
    Greater(Expr),
    Type(ProtoRef, Box<Pattern>),
    Unwrap {
        depth: u32,
        inner: Box<Pattern>,
    },
    Or(Box<Pattern>, Box<Pattern>),
    Unit,
    List {
        elems: Vec<Pattern>,
        rest: Option<Box<Pattern>>,
    },
    Map {
        entries: Vec<(MapKey, Pattern)>,
        rest: Option<Box<Pattern>>,
    },
    When {
        inner: Box<Pattern>,
        when: (Option<Box<Pattern>>, Expr),
    },
}

A pattern: the left-hand side of a binding (&<pat> …, let (<pat> = …), or a __match clause). Matched by the evaluator’s native matcher (match_pattern in eval.rs). Bind/Discard are irrefutable.

Variants

Discard

_ — matches any value without binding.

Bind(Text)

name — binds the subject to name. A cell is consed onto the environment; names are resolved to de Bruijn indices at parse time.

At(Text, Box<Pattern>)

name = <pat> — binds the subject to name, then matches <pat> against the same subject.

Equal(Expr)

= <expr> — matches if the subject equals the value of <expr>. Evaluation errors propagate; they are not refutations.

Less(Expr)

< <expr> — matches if the subject is ordered before the value of <expr>. Only defined for comparable kinds (e.g., Int); others refute with .not_int.

Greater(Expr)

> <expr> — matches if the subject is ordered after the value of <expr>.

Type(ProtoRef, Box<Pattern>)

<pat> as <Proto> — matches if the subject’s prototype is <Proto>, then matches <pat> against the subject.

Unwrap

Self <pat> — matches if the subject is an object of the home module and its payload matches <pat>. Prototype check is implicit. depth is the distance to the home module terminal.

Fields

depth: u32

inner: Box<Pattern>

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

(p1 | p2) — tries arms sequentially. Both arms must bind the same names. Once an arm matches, the pattern is committed (no backtracking).

Unit

&() — matches only the unit value.

List

[p0, ...] list pattern. rest handles the remainder: None for exact arity, Some(Discard) for minimum arity, or Some(Bind(name)) to bind.

Fields

elems: Vec<Pattern>

rest: Option<Box<Pattern>>

Map

{ k0: p0, ... } map pattern. rest handles the remainder similarly to lists.

Fields

entries: Vec<(MapKey, Pattern)>

rest: Option<Box<Pattern>>

When

<pat> when (<cond>) guarded pattern. Matches inner, then the guard. Plain guards must be Bool; pattern guards match gpat against the condition.

Fields

inner: Box<Pattern>

when: (Option<Box<Pattern>>, Expr)

Trait Implementations

impl Clone for Pattern

fn clone(&self) -> Pattern

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

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