Struct hugr::types::TypeBase

pub struct TypeBase<RV>(/* private fields */)
where
    RV: MaybeRV;

A HUGR type - the valid types of EdgeKind::Value and EdgeKind::Const edges. Such an edge is valid if the ports on either end agree on the Type. Types have an optional TypeBound which places limits on the valid operations on a type.

Examples:

let sum = Type::new_sum([type_row![], type_row![]]);
assert_eq!(sum.least_upper_bound(), TypeBound::Copyable);

let func_type: Type = Type::new_function(Signature::new_endo(vec![]));
assert_eq!(func_type.least_upper_bound(), TypeBound::Copyable);

Implementations

impl<RV> TypeBase<RV>

where RV: MaybeRV,

pub const EMPTY_TYPEROW: TypeRowBase<RV> = _

An empty TypeRow or TypeRowRV. Provided here for convenience

pub const UNIT: TypeBase<RV> = _

Unit type (empty tuple).

pub fn new_function( fun_ty: impl Into<FuncTypeBase<RowVariable>>, ) -> TypeBase<RV>

Initialize a new function type.

pub fn new_tuple(types: impl Into<TypeRowBase<RowVariable>>) -> TypeBase<RV>

Initialize a new tuple type by providing the elements.

pub fn new_sum<R>(variants: impl IntoIterator<Item = R>) -> TypeBase<RV>

where R: Into<TypeRowBase<RowVariable>>,

Initialize a new sum type by providing the possible variant types.

pub const fn new_extension(opaque: CustomType) -> TypeBase<RV>

Initialize a new custom type.

pub fn new_alias(alias: AliasDecl) -> TypeBase<RV>

Initialize a new alias.

pub const fn new_unit_sum(size: u8) -> TypeBase<RV>

New UnitSum with empty Tuple variants

pub const fn new_var_use(idx: usize, bound: TypeBound) -> TypeBase<RV>

New use (occurrence) of the type variable with specified index. bound must be exactly that with which the variable was declared (i.e. as a TypeParam::Type(bound)), which may be narrower than required for the use.

pub const fn least_upper_bound(&self) -> TypeBound

Report the least upper TypeBound

pub const fn as_type_enum(&self) -> &TypeEnum<RV>

Report the component TypeEnum.

pub const fn copyable(&self) -> bool

Report if the type is copyable - i.e.the least upper bound of the type is contained by the copyable bound.

impl TypeBase<RowVariable>

pub fn is_row_var(&self) -> bool

Tells if this Type is a row variable, i.e. could stand for any number >=0 of Types

pub const fn new_row_var_use( idx: usize, bound: TypeBound, ) -> TypeBase<RowVariable>

New use (occurrence) of the row variable with specified index. bound must match that with which the variable was declared (i.e. as a TypeParam::Listof aTypeParam::Type` of that bound). For use in OpDef, not FuncDefn, type schemes only.

impl<RV> TypeBase<RV>

where RV: MaybeRV,

pub fn try_into_type(self) -> Result<TypeBase<NoRV>, RowVariable>

(Fallibly) converts a TypeBase (parameterized, so may or may not be able to contain RowVariables) into a Type that definitely does not.

Trait Implementations

impl<RV> Clone for TypeBase<RV>

where RV: Clone + MaybeRV,

fn clone(&self) -> TypeBase<RV>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<RV> Debug for TypeBase<RV>

where RV: Debug + MaybeRV,

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

Formats the value using the given formatter.

impl<'de, RV> Deserialize<'de> for TypeBase<RV>

where RV: MaybeRV + Deserialize<'de>,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<RV> Display for TypeBase<RV>

where RV: MaybeRV, TypeEnum<RV>: Display,

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

Formats the value using the given formatter.

impl From<CustomType> for TypeBase<NoRV>

fn from(value: CustomType) -> TypeBase<NoRV>

Converts to this type from the input type.

impl<RV> From<SumType> for TypeBase<RV>

where RV: MaybeRV,

fn from(sum: SumType) -> TypeBase<RV>

Converts to this type from the input type.

impl From<TypeBase<NoRV>> for TypeBase<RowVariable>

fn from(value: TypeBase<NoRV>) -> TypeBase<RowVariable>

Converts to this type from the input type.

impl From<TypeBase<NoRV>> for TypeRowBase<NoRV>

fn from(t: TypeBase<NoRV>) -> TypeRowBase<NoRV>

Converts to this type from the input type.

impl<RV> From<TypeBase<RV>> for TypeArg

where RV: MaybeRV,

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

Converts to this type from the input type.

impl<RV1> From<TypeBase<RV1>> for TypeRowBase<RowVariable>

where RV1: MaybeRV,

fn from(t: TypeBase<RV1>) -> TypeRowBase<RowVariable>

Converts to this type from the input type.

impl<RV> Hash for TypeBase<RV>

where RV: Hash + MaybeRV,

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<RV1, RV2> PartialEq<TypeBase<RV1>> for TypeBase<RV2>

where RV1: MaybeRV, RV2: MaybeRV,

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

where RV: MaybeRV + Serialize,

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<RV> TryFrom<SerSimpleType> for TypeBase<RV>

where RV: MaybeRV,

type Error = SignatureError

The type returned in the event of a conversion error.

fn try_from( value: SerSimpleType, ) -> Result<TypeBase<RV>, <TypeBase<RV> as TryFrom<SerSimpleType>>::Error>

Performs the conversion.

impl TryFrom<TypeBase<RowVariable>> for TypeBase<NoRV>

type Error = RowVariable

The type returned in the event of a conversion error.

fn try_from(value: TypeBase<RowVariable>) -> Result<TypeBase<NoRV>, RowVariable>

Performs the conversion.

impl<RV> Eq for TypeBase<RV>

where RV: Eq + MaybeRV,