Enum Term 

#[non_exhaustive]
pub enum Term {
    RuntimeType(TypeBound),
    StaticType,
    BoundedNatType(UpperBound),
    StringType,
    BytesType,
    FloatType,
    ListType(Box<Term>),
    TupleType(Box<Term>),
    Runtime(TypeBase<NoRV>),
    BoundedNat(u64),
    String(String),
    Bytes(Arc<[u8]>),
    Float(OrderedFloat<f64>),
    List(Vec<Term>),
    ListConcat(Vec<Term>),
    Tuple(Vec<Term>),
    TupleConcat(Vec<Term>),
    Variable(TermVar),
    ConstType(Box<TypeBase<NoRV>>),
}

A term in the language of static parameters in HUGR.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

RuntimeType(TypeBound)

The type of runtime types.

StaticType

The type of static data.

BoundedNatType(UpperBound)

The type of static natural numbers up to a given bound.

StringType

The type of static strings. See Term::String.

BytesType

The type of static byte strings. See Term::Bytes.

FloatType

The type of static floating point numbers. See Term::Float.

ListType(Box<Term>)

The type of static lists of indeterminate size containing terms of the specified static type.

TupleType(Box<Term>)

The type of static tuples.

Runtime(TypeBase<NoRV>)

A runtime type as a term. Instance of Term::RuntimeType.

BoundedNat(u64)

A 64bit unsigned integer literal. Instance of Term::BoundedNatType.

String(String)

UTF-8 encoded string literal. Instance of Term::StringType.

Bytes(Arc<[u8]>)

Byte string literal. Instance of Term::BytesType.

Float(OrderedFloat<f64>)

A 64-bit floating point number. Instance of Term::FloatType.

List(Vec<Term>)

A list of static terms. Instance of Term::ListType.

ListConcat(Vec<Term>)

Instance of TypeParam::List defined by a sequence of concatenated lists of the same type.

Tuple(Vec<Term>)

Instance of TypeParam::Tuple defined by a sequence of elements of varying type.

TupleConcat(Vec<Term>)

Instance of TypeParam::Tuple defined by a sequence of concatenated tuples.

Variable(TermVar)

Variable (used in type schemes or inside polymorphic functions), but not a runtime type (not even a row variable i.e. list of runtime types)

• see Term::new_var_use

ConstType(Box<TypeBase<NoRV>>)

The type of constants for a runtime type.

A constant is a compile time description of how to produce a runtime value. The runtime value is constructed when the constant is loaded.

Constants are distinct from the runtime values that they describe. In particular, as part of the term language, constants can be freely copied or destroyed even when they describe a non-linear runtime value.

Implementations

impl Term

pub const fn max_nat_type() -> Term

Creates a Term::BoundedNatType with the maximum bound (u64::MAX + 1).

pub const fn bounded_nat_type(upper_bound: NonZero<u64>) -> Term

Creates a Term::BoundedNatType with the stated upper bound (non-exclusive).

pub fn new_list(items: impl IntoIterator<Item = Term>) -> Term

Creates a new Term::List given a sequence of its items.

pub fn new_list_type(elem: impl Into<Term>) -> Term

Creates a new Term::ListType given the type of its elements.

pub fn new_tuple_type(item_types: impl Into<Term>) -> Term

Creates a new Term::TupleType given the type of its elements.

pub fn new_const(ty: impl Into<TypeBase<NoRV>>) -> Term

Creates a new Term::ConstType from a runtime type.

impl Term

pub const UNIT: Term

Type::UNIT as a Term::Runtime

pub fn new_var_use(idx: usize, decl: Term) -> Term

Makes a TypeArg representing a use (occurrence) of the type variable with the specified index. decl must be exactly that with which the variable was declared.

pub fn new_string(str: impl ToString) -> Term

Creates a new string literal.

pub fn new_list_concat(lists: impl IntoIterator<Item = Term>) -> Term

Creates a new concatenated list.

pub fn new_tuple(items: impl IntoIterator<Item = Term>) -> Term

Creates a new tuple from its items.

pub fn new_tuple_concat(tuples: impl IntoIterator<Item = Term>) -> Term

Creates a new concatenated tuple.

pub fn as_nat(&self) -> Option<u64>

Returns an integer if the Term is a natural number literal.

pub fn as_runtime(&self) -> Option<TypeBase<NoRV>>

Returns a Type if the Term is a runtime type.

pub fn as_string(&self) -> Option<String>

Returns a string if the Term is a string literal.

pub fn new_list_from_parts( parts: impl IntoIterator<Item = SeqPart<Term>>, ) -> Term

Creates a new list from a sequence of SeqParts.

pub fn into_list_parts(self) -> ListPartIter

Iterates over the SeqParts of a list.

Examples

The parts of a closed list are the items of that list wrapped in SeqPart::Item:

let term = Term::new_list([a.clone(), b.clone()]);

assert_eq!(
    term.into_list_parts().collect::<Vec<_>>(),
    vec![SeqPart::Item(a), SeqPart::Item(b)]
);

Parts of a concatenated list that are not closed lists are wrapped in SeqPart::Splice:

let var = Term::new_var_use(0, Term::new_list_type(Term::StringType));
let term = Term::new_list_concat([
    Term::new_list([a.clone(), b.clone()]),
    var.clone(),
    Term::new_list([c.clone()])
 ]);

assert_eq!(
    term.into_list_parts().collect::<Vec<_>>(),
    vec![SeqPart::Item(a), SeqPart::Item(b), SeqPart::Splice(var), SeqPart::Item(c)]
);

Nested concatenations are traversed recursively:

let term = Term::new_list_concat([
    Term::new_list_concat([
        Term::new_list([a.clone()]),
        Term::new_list([b.clone()])
    ]),
    Term::new_list([]),
    Term::new_list([c.clone()])
]);

assert_eq!(
    term.into_list_parts().collect::<Vec<_>>(),
    vec![SeqPart::Item(a), SeqPart::Item(b), SeqPart::Item(c)]
);

When invoked on a type argument that is not a list, a single SeqPart::Splice is returned that wraps the type argument. This is the expected behaviour for type variables that stand for lists. This behaviour also allows this method not to fail on ill-typed type arguments.

let term = Term::new_string("not a list");
assert_eq!(
    term.clone().into_list_parts().collect::<Vec<_>>(),
    vec![SeqPart::Splice(term)]
);

pub fn new_tuple_from_parts( parts: impl IntoIterator<Item = SeqPart<Term>>, ) -> Term

Creates a new tuple from a sequence of SeqParts.

Analogous to TypeArg::new_list_from_parts.

pub fn into_tuple_parts(self) -> TuplePartIter

Iterates over the SeqParts of a tuple.

Analogous to TypeArg::into_list_parts.

Trait Implementations

impl Clone for Term

fn clone(&self) -> Term

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Term

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Term

fn deserialize<__D>( __deserializer: __D, ) -> Result<Term, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Term

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

Formats the value using the given formatter.

impl From<&str> for Term

fn from(arg: &str) -> Term

Converts to this type from the input type.

impl<const N: usize> From<[Term; N]> for Term

fn from(value: [Term; N]) -> Term

Converts to this type from the input type.

impl From<ArrayOrTermSer> for Term

fn from(value: ArrayOrTermSer) -> Term

Converts to this type from the input type.

impl From<String> for Term

fn from(arg: String) -> Term

Converts to this type from the input type.

impl From<TermSer> for Term

fn from(value: TermSer) -> Term

Converts to this type from the input type.

impl<RV> From<TypeBase<RV>> for Term

where RV: MaybeRV,

fn from(value: TypeBase<RV>) -> Term

Converts to this type from the input type.

impl From<TypeBound> for Term

fn from(bound: TypeBound) -> Term

Converts to this type from the input type.

impl From<TypeRowBase<NoRV>> for Term

fn from(value: TypeRowBase<NoRV>) -> Term

Converts to this type from the input type.

impl From<TypeRowBase<RowVariable>> for Term

fn from(value: TypeRowBase<RowVariable>) -> Term

Converts to this type from the input type.

impl From<UpperBound> for Term

fn from(bound: UpperBound) -> Term

Converts to this type from the input type.

impl From<Vec<Term>> for Term

fn from(elems: Vec<Term>) -> Term

Converts to this type from the input type.

impl From<u64> for Term

fn from(n: u64) -> Term

Converts to this type from the input type.

impl Hash for Term

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

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

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

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Transformable for Term

fn transform<T>(&mut self, tr: &T) -> Result<bool, <T as TypeTransformer>::Err>

where T: TypeTransformer,

Applies a TypeTransformer to this instance.

impl TryFrom<Term> for TypeBase<RowVariable>

type Error = SignatureError

The type returned in the event of a conversion error.

fn try_from( value: Term, ) -> Result<TypeBase<RowVariable>, <TypeBase<RowVariable> as TryFrom<Term>>::Error>

Performs the conversion.

impl TryFrom<Term> for TypeRowBase<NoRV>

type Error = SignatureError

The type returned in the event of a conversion error.

fn try_from( value: Term, ) -> Result<TypeRowBase<NoRV>, <TypeRowBase<NoRV> as TryFrom<Term>>::Error>

Performs the conversion.

impl TryFrom<Term> for TypeRowBase<RowVariable>

type Error = SignatureError

The type returned in the event of a conversion error.

fn try_from( value: Term, ) -> Result<TypeRowBase<RowVariable>, <TypeRowBase<RowVariable> as TryFrom<Term>>::Error>

Performs the conversion.

impl Eq for Term

impl StructuralPartialEq for Term