Trait canrun::value::ReifyIn

pub trait ReifyIn<'a, D>: Sized {
    type Reified;
    fn reify_in(&self, state: &ResolvedState<D>) -> Option<Self::Reified>;
}

Extract a fully resolved T from a Val<T>.

Used by query to ensure that result values are fully and recursively resolved.

Associated Types

type Reified

The "concrete" type that Self reifies to.

Loading content...

Required methods

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.

Examples:

Simple values are typically copied or cloned (since the Val stores in an Rc internally).

use canrun::{Val, val, var, ReifyIn, IterResolved, State, ResolvedState};
use canrun::example::{I32, TupleI32};
State::new()
    .iter_resolved()
    .for_each(|state: ResolvedState<I32>| {
        let x = val!(1);
        assert_eq!(x.reify_in(&state), Some(1));
    });

Structures containing additional Vals should be recursively reified.

State::new()
    .iter_resolved()
    .for_each(|state: ResolvedState<TupleI32>| {
        let x = (val!(1), val!(2));
        assert_eq!(x.reify_in(&state), Some((1, 2)));
    });

Returns None if the Val is unresolved.

State::new()
    .iter_resolved()
    .for_each(|state: ResolvedState<I32>| {
        let x: Val<i32> = val!(var());
        assert_eq!(x.reify_in(&state), None);
    });

Also returns None if Self is a structure containing any unresolved Vals.

State::new()
    .iter_resolved()
    .for_each(|state: ResolvedState<TupleI32>| {
        let x: Val<i32> = val!(var());
        let y = (x, val!(2));
        assert_eq!(y.reify_in(&state), None);
    });

Loading content...

Implementations on Foreign Types

impl<'a, D: Domain<'a>> ReifyIn<'a, D> for i8

type Reified = i8

fn reify_in(&self, _: &ResolvedState<D>) -> Option<i8>

impl<'a, D: Domain<'a>> ReifyIn<'a, D> for i16

type Reified = i16

fn reify_in(&self, _: &ResolvedState<D>) -> Option<i16>

impl<'a, D: Domain<'a>> ReifyIn<'a, D> for i32

type Reified = i32

fn reify_in(&self, _: &ResolvedState<D>) -> Option<i32>

impl<'a, D: Domain<'a>> ReifyIn<'a, D> for i64

type Reified = i64

fn reify_in(&self, _: &ResolvedState<D>) -> Option<i64>

impl<'a, D: Domain<'a>> ReifyIn<'a, D> for u8

type Reified = u8

fn reify_in(&self, _: &ResolvedState<D>) -> Option<u8>

impl<'a, D: Domain<'a>> ReifyIn<'a, D> for u16

type Reified = u16

fn reify_in(&self, _: &ResolvedState<D>) -> Option<u16>

impl<'a, D: Domain<'a>> ReifyIn<'a, D> for u32

type Reified = u32

fn reify_in(&self, _: &ResolvedState<D>) -> Option<u32>

impl<'a, D: Domain<'a>> ReifyIn<'a, D> for u64

type Reified = u64

fn reify_in(&self, _: &ResolvedState<D>) -> Option<u64>

impl<'a, D: Domain<'a>> ReifyIn<'a, D> for isize

type Reified = isize

fn reify_in(&self, _: &ResolvedState<D>) -> Option<isize>

impl<'a, D: Domain<'a>> ReifyIn<'a, D> for usize

type Reified = usize

fn reify_in(&self, _: &ResolvedState<D>) -> Option<usize>

impl<'a, D: Domain<'a>> ReifyIn<'a, D> for f32

type Reified = f32

fn reify_in(&self, _: &ResolvedState<D>) -> Option<f32>

impl<'a, D: Domain<'a>> ReifyIn<'a, D> for f64

type Reified = f64

fn reify_in(&self, _: &ResolvedState<D>) -> Option<f64>

impl<'a, D: Domain<'a>> ReifyIn<'a, D> for String

type Reified = String

fn reify_in(&self, _: &ResolvedState<D>) -> Option<String>

impl<'a, D: Domain<'a>> ReifyIn<'a, D> for &'static str

type Reified = &'static str

fn reify_in(&self, _: &ResolvedState<D>) -> Option<&'static str>

impl<'a, D: Domain<'a>> ReifyIn<'a, D> for bool

type Reified = bool

fn reify_in(&self, _: &ResolvedState<D>) -> Option<bool>

impl<'a, D: Domain<'a>> ReifyIn<'a, D> for char

type Reified = char

fn reify_in(&self, _: &ResolvedState<D>) -> Option<char>

impl<'a, D: 'a, Av: ReifyIn<'a, D, Reified = Ar>, Ar, Bv: ReifyIn<'a, D, Reified = Br>, Br> ReifyIn<'a, D> for (Av, Bv)

type Reified = (Av::Reified, Bv::Reified)

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

impl<'a, D: 'a, Av: ReifyIn<'a, D, Reified = Ar>, Ar, Bv: ReifyIn<'a, D, Reified = Br>, Br, Cv: ReifyIn<'a, D, Reified = Cr>, Cr> ReifyIn<'a, D> for (Av, Bv, Cv)

type Reified = (Av::Reified, Bv::Reified, Cv::Reified)

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

impl<'a, D: 'a, Av: ReifyIn<'a, D, Reified = Ar>, Ar, Bv: ReifyIn<'a, D, Reified = Br>, Br, Cv: ReifyIn<'a, D, Reified = Cr>, Cr, Dv: ReifyIn<'a, D, Reified = Dr>, Dr> ReifyIn<'a, D> for (Av, Bv, Cv, Dv)

type Reified = (Av::Reified, Bv::Reified, Cv::Reified, Dv::Reified)

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

impl<'a, D: 'a, Av: ReifyIn<'a, D, Reified = Ar>, Ar, Bv: ReifyIn<'a, D, Reified = Br>, Br, Cv: ReifyIn<'a, D, Reified = Cr>, Cr, Dv: ReifyIn<'a, D, Reified = Dr>, Dr, Ev: ReifyIn<'a, D, Reified = Er>, Er> ReifyIn<'a, D> for (Av, Bv, Cv, Dv, Ev)

type Reified = (Av::Reified, Bv::Reified, Cv::Reified, Dv::Reified, Ev::Reified)

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

impl<'a, '_, T, D> ReifyIn<'a, D> for &'_ T where
    T: ReifyIn<'a, D>,
    D: Domain<'a> + 'a, 

type Reified = T::Reified

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

Loading content...

Implementors

impl<'a, D, Kv: Eq + Hash + Debug, Kr, Vv: Debug, Vr> ReifyIn<'a, D> for LMap<Kv, Vv> where
    D: DomainType<'a, Kv> + DomainType<'a, Vv> + 'a,
    Kv: ReifyIn<'a, D, Reified = Kr>,
    Kr: Eq + Hash,
    Vv: ReifyIn<'a, D, Reified = Vr>, 

type Reified = HashMap<Kr, Vr>

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

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

type Reified = Vec<T::Reified>

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

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

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

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

type Reified = T::Reified

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

Loading content...