Enum Term

pub enum Term<'a> {
    Wildcard,
    Var(VarId),
    Apply(NodeId, &'a [TermId]),
    List(&'a [SeqPart]),
    Literal(Literal),
    Func(RegionId),
    Tuple(&'a [SeqPart]),
}

A term in the compile time meta language.

See ast::Term for the AST representation.

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 [SeqPart])

List of static data.

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

Type: (core.list ?t)

Literal(Literal)

A static literal value.

Func(RegionId)

A constant anonymous function.

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

Tuple(&'a [SeqPart])

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 From<Literal> for Term<'_>

fn from(value: Literal) -> Self

Converts to this type from the input 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>