Enum Pat 

pub enum Pat {
    None,
    Discard,
    Unit,
    Bind(Sym),
    At(Sym, PatId),
    Equal(NodeId),
    Less(NodeId),
    Greater(NodeId),
    TypeKind(TyKind, PatId),
    TypeRef(NodeId, PatId),
    Unwrap {
        depth: u32,
        inner: PatId,
    },
    Or(PatId, PatId),
    List {
        len: u32,
        elems: PatId,
        rest: PatId,
    },
    Map {
        len: u32,
        entries: PatId,
        rest: PatId,
    },
    Lookup(NodeId),
    When {
        inner: PatId,
        gpat: PatId,
        cond: NodeId,
    },
    Barrier {
        run: Run,
        len: u32,
    },
}

A pattern, 16 bytes like Node.

Variants

None

The slot of a block clause that binds nothing.

Discard

Unit

Bind(Sym)

At(Sym, PatId)

Equal(NodeId)

Less(NodeId)

Greater(NodeId)

TypeKind(TyKind, PatId)

<pat> as <Kind>, a builtin prototype.

TypeRef(NodeId, PatId)

<pat> as <Proto>, any other prototype, evaluated at match time.

Unwrap

Fields

depth: u32

inner: PatId

Or(PatId, PatId)

List

rest is PatId::NONE for an exact-length list.

Fields

len: u32

elems: PatId

rest: PatId

Map

The run is the len key patterns, then the len value patterns. A key is a Lookup or a pattern that captures the key.

Fields

len: u32

entries: PatId

rest: PatId

Lookup(NodeId)

A map pattern’s looked-up key.

When

gpat is PatId::NONE for a plain guard.

Fields

inner: PatId

gpat: PatId

cond: NodeId

Barrier

Stands before a run in debug builds.

Fields

run: Run

len: u32

Trait Implementations

impl Clone for Pat

fn clone(&self) -> Pat

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for Pat

impl Debug for Pat

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

Formats the value using the given formatter.

impl Eq for Pat

impl PartialEq for Pat

fn eq(&self, other: &Pat) -> 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 Pat