Enum canrun::core::Value

pub enum Value<T: Unify> {
    Var(LVar<T>),
    Resolved(Rc<T>),
}

Contain individual resolved values or variables that can be bound through unification.

Variants

Var(LVar<T>)

A logical variable.

Even though they do not contain a value, they are parameterized with the type they can potentially be bound to. This ensures that they can only be unified with values of the same type.

Resolved(Rc<T>)

A resolved value.

When a state is split into an arbitrary number of resolved states, some of the internal data structures often need to be cloned. In an attempt to avoid unnecessary cloning of every value in the state, we wrap it in an Rc so that references can be shared.

Implementations

impl<T: Unify> Value<T>

pub fn new(t: T) -> Value<T>

Create a new logical Value wrapping a T.

Example:

use canrun::Value;
let x: Value<i32> = Value::new(1);

pub fn var() -> Value<T>

Create a new logical Value with an unresolved Var.

This is a shorthand for Value::Var(LVar::new()).

Example:

use canrun::Value;
let x: Value<i32> = Value::var();

pub fn resolved(&self) -> Option<&T>

Return T if the Value is a resolved.

Example:

use canrun::Value;

let x: Value<i32> = Value::new(1);
assert_eq!(x.resolved(), Some(&1));

Trait Implementations

impl<T: Unify> Clone for Value<T>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug + Unify> Debug for Value<T>

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

Formats the value using the given formatter.

impl<T: Unify> From<&LVar<T>> for Value<T>

fn from(var: &LVar<T>) -> Self

Converts to this type from the input type.

impl<T: Unify> From<&Value<T>> for Value<T>

fn from(var: &Value<T>) -> Self

Converts to this type from the input type.

impl<T: Unify> From<LVar<T>> for Value<T>

fn from(var: LVar<T>) -> Self

Converts to this type from the input type.

impl<T: Unify> From<T> for Value<T>

fn from(t: T) -> Self

Converts to this type from the input type.

impl<T: Unify> FromIterator<Value<T>> for LVec<T>

fn from_iter<I: IntoIterator<Item = Value<T>>>(iter: I) -> Self

Creates a value from an iterator.

impl<T: Hash + Unify> Hash for Value<T>

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<T: PartialEq + Unify> PartialEq<Value<T>> for Value<T>

fn eq(&self, other: &Value<T>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: Unify + Reify> Reify for Value<T>

type Reified = <T as Reify>::Reified

The “concrete” type that Self reifies to.

fn reify_in(&self, state: &ReadyState) -> Option<Self::Reified>

Extract a reified Self from a compatible State. This trait is usually used indirectly through the Query trait.

impl<T: Eq + Unify> Eq for Value<T>

impl<T: Unify> StructuralEq for Value<T>

impl<T: Unify> StructuralPartialEq for Value<T>