Enum canrun::value::Val

pub enum Val<T: Debug + ?Sized> {
    Var(LVar<T>),
    Resolved(Rc<T>),
}

The possible states a value can be in.

Variants

Var

A logical variable.

Tuple Fields of Var

0: LVar<T>

Resolved

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.

Tuple Fields of Resolved

0: Rc<T>

Implementations

impl<T: Debug> Val<T>

pub fn resolved(&self) -> Result<&T, LVar<T>>

Attempt to extract a reference to resolved value (&T) or return the LVar if the value is not yet resolved.

Examples:

use canrun::{var, val, LVar};

let x: LVar<i32> = var();
let x_val = val!(x);
assert_eq!(x_val.resolved(), Err(x));

let y_val = val!(1);
assert_eq!(y_val.resolved(), Ok(&1));

pub fn is_var(&self) -> bool

Return true if the Val is an unresolved variable.

Example:

use canrun::{var, val, Val};

let x: Val<i32> = val!(var());
assert!(x.is_var());

pub fn is_resolved(&self) -> bool

Return true if the Val is a resolved value.

Example:

use canrun::{var, val, Val};

let x: Val<i32> = val!(1);
assert!(x.is_resolved());

Trait Implementations

impl<T: Debug> Clone for Val<T>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a, T: Debug> Debug for Val<T>

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

Formats the value using the given formatter.

impl<T: Hash + Debug> Hash for Val<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, 

Feeds a slice of this type into the given Hasher.

impl<T: Debug> IntoVal<T> for Val<T>

fn into_val(self) -> Val<T>

Convert various T related values into a Val<T>.

impl<T: Debug> IntoVal<T> for &Val<T>

fn into_val(self) -> Val<T>

Convert various T related values into a Val<T>.

impl<T: PartialEq + Debug> PartialEq<Val<T>> for Val<T>

fn eq(&self, other: &Val<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 !=.

impl<'a, T, D> ReifyIn<'a, D> for Val<T> where
    T: ReifyIn<'a, D> + Debug,
    D: DomainType<'a, T> + 'a, 

type Reified = T::Reified

The “concrete” type that Self reifies to.

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

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

impl<T: Eq + Debug> Eq for Val<T>