Enum Value

pub enum Value {
    Extension {
        e: OpaqueValue,
    },
    Function {
        hugr: Box<Hugr>,
    },
    Sum(Sum),
}

A value that can be stored as a static constant. Representing core types and extension types.

Variants

Extension

An extension constant value, that can check it is of a given CustomType.

Fields

e: OpaqueValue

The custom constant value.

Function

A higher-order function value.

Fields

hugr: Box<Hugr>

A Hugr defining the function.

Sum(Sum)

A Sum variant, with a tag indicating the index of the variant and its value.

Implementations

impl Value

pub fn get_type(&self) -> Type

Returns the type of this Value.

pub fn sum( tag: usize, items: impl IntoIterator<Item = Value>, typ: SumType, ) -> Result<Self, ConstTypeError>

Returns a Sum constant. The value is determined by items and is type-checked typ. The tagth variant of typ should match the types of items.

pub fn tuple(items: impl IntoIterator<Item = Value>) -> Self

Returns a tuple constant of constant values.

pub fn function(hugr: impl Into<Hugr>) -> Result<Self, ConstTypeError>

Returns a constant function defined by a Hugr.

Errors

Returns an error if the Hugr root node does not define a function.

pub const fn unit() -> Self

Returns a constant unit type (empty Tuple).

pub fn unit_sum(tag: usize, size: u8) -> Result<Self, ConstTypeError>

Returns a constant Sum over units. Used as branching values.

pub fn unary_unit_sum() -> Self

Returns a constant Sum over units, with only one variant.

pub fn true_val() -> Self

Returns a constant “true” value, i.e. the second variant of Sum((), ()).

pub fn false_val() -> Self

Returns a constant “false” value, i.e. the first variant of Sum((), ()).

pub fn some<V: Into<Value>>(values: impl IntoIterator<Item = V>) -> Self

Returns an optional with some values. This is a Sum with two variants, the first being empty and the second being the values.

pub fn none(value_types: impl Into<TypeRow>) -> Self

Returns an optional with no value. This is a Sum with two variants, the first being empty and the second being the value.

pub fn from_bool(b: bool) -> Self

Returns a constant bool value.

see Value::true_val and Value::false_val.

pub fn extension(custom_const: impl CustomConst) -> Self

Returns a Value::Extension holding custom_const.

pub fn get_custom_value<T: CustomConst>(&self) -> Option<&T>

For a Value holding a CustomConst, extract the CustomConst by downcasting.

pub fn validate(&self) -> Result<(), ConstTypeError>

Check the value.

pub fn as_tuple(&self) -> Option<&[Value]>

If value is a sum with a single row variant, return the row.

pub fn try_hash<H: Hasher>(&self, st: &mut H) -> bool

Hashes this value, if possible. Value::Extensions are hashable according to their implementation of TryHash; Value::Functions never are; Value::Sums are if their contents are.

Trait Implementations

impl AsRef<Value> for Const

fn as_ref(&self) -> &Value

Converts this type into a shared reference of the (usually inferred) input type.

impl Clone for Value

fn clone(&self) -> Value

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Value

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Value

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<Const> for Value

fn from(konst: Const) -> Self

Converts to this type from the input type.

impl<T> From<T> for Value

where T: CustomConst,

fn from(value: T) -> Self

Converts to this type from the input type.

impl From<Value> for Const

fn from(value: Value) -> Self

Converts to this type from the input type.

impl PartialEq for Value

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

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Value