Enum Term

pub enum Term<'a> {
    Wildcard,
    Var(VarId),
    Apply(NodeId, &'a [TermId]),
    List(&'a [ListPart]),
    Str(&'a str),
    Nat(u64),
    ExtSet(&'a [ExtSetPart<'a>]),
    ConstFunc(RegionId),
    Bytes(&'a [u8]),
    Float(OrderedFloat<f64>),
    Tuple(&'a [TuplePart]),
}

A term in the compile time meta language.

Variants

Wildcard

Standin for any term.

Var(VarId)

A local variable.

Apply(NodeId, &'a [TermId])

Apply a symbol to a sequence of arguments.

The symbol is defined by a node in the same graph. The type of this term is derived from instantiating the symbol’s parameters in the symbol’s signature.

List(&'a [ListPart])

List of static data.

Lists can include individual items or other lists to be spliced in.

Type: (core.list ?t)

Str(&'a str)

A literal string.

Type: core.str

Nat(u64)

A literal natural number.

Type: core.nat

ExtSet(&'a [ExtSetPart<'a>])

Extension set.

Type: core.ext_set

ConstFunc(RegionId)

A constant anonymous function.

Type: (core.const (core.fn ?ins ?outs ?ext) (ext))

Bytes(&'a [u8])

A literal byte string.

Type:: core.bytes

Float(OrderedFloat<f64>)

A literal floating-point number.

Type: core.float

Tuple(&'a [TuplePart])

Tuple of static data.

Tuples can include individual items or other tuples to be spliced in.

Type: (core.tuple ?types)

Trait Implementations

impl<'a> Clone for Term<'a>

fn clone(&self) -> Term<'a>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Term<'a>

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

Formats the value using the given formatter.

impl<'a> Default for Term<'a>

fn default() -> Term<'a>

Returns the “default value” for a type.

impl<'a> Hash for Term<'a>

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<'a> PartialEq for Term<'a>

fn eq(&self, other: &Term<'a>) -> 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<'a> Eq for Term<'a>

impl<'a> StructuralPartialEq for Term<'a>