Struct Intermediate

pub struct Intermediate<T>(/* private fields */);

A helper type for defining intermediate Computations. This will consist of any non-input in a program. These are always functions which are cached and derive their value from other functions or inputs.

Implementations

impl<T> Intermediate<T>

pub const fn new(x: T) -> Self

Trait Implementations

impl<T: Clone> Clone for Intermediate<T>

fn clone(&self) -> Intermediate<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Computation for Intermediate<T>

where T: Run + Clone + 'static,

type Output = <T as Run>::Output

type Storage = ()

fn run(&self, handle: &mut DbHandle<'_, impl Computation>) -> Self::Output

fn input_to_cell(_: &Self, _: &Self::Storage) -> Option<Cell>

fn get_function_and_output( _: Cell, _: &Self::Storage, ) -> (&Self, Option<&Self::Output>)

fn set_output(_: Cell, _: Self::Output, _: &mut Self::Storage)

fn insert_new_cell(_: Cell, _: Self, _: &mut Self::Storage)

fn computation_id_of<T: Computation>() -> u32

fn get_storage<Concrete: Computation + 'static>( computation_id: u32, container: &Self::Storage, ) -> &Concrete::Storage

fn get_storage_mut<Concrete: Computation + 'static>( computation_id: u32, container: &mut Self::Storage, ) -> &mut Concrete::Storage

fn output_is_unset<FullComputation: Computation>( cell: Cell, computation_id: u32, original_computation_id: u32, db: &Db<FullComputation>, ) -> bool

True if this has any cached output

fn dispatch_run<FullComputation: Computation>( cell: Cell, computation_id: u32, original_computation_id: u32, db: &mut Db<FullComputation>, ) -> bool

where Self: Clone, Self::Output: Eq,

Given a Cell, TypeId pair dispatch to the correct run function and return true if the value has changed. This should also cache the new value if it has changed. Note that in dispatch functions Self is always the concrete, non-tuple type.

fn dispatch_update_output<Concrete, FullComputation>( cell: Cell, computation_id: u32, original_computation_id: u32, output: Concrete::Output, db: &mut Db<FullComputation>, ) -> bool

where Concrete: Computation, FullComputation: Computation, Self::Output: Eq,

Dispatch to the correct update_output function to cache the new output and return true if the value has changed. Note that in dispatch functions Self is the current type being dispatched, Concrete, if present, is the non-tuple type of the target computation, and FullComputation is the type of the Db computation parameter which is usually a tuple of every possible computation.

fn dispatch_input_to_cell<Concrete>( input: &Concrete, container: &Self::Storage, ) -> Option<Cell>

where Concrete: 'static + Computation + Any,

fn dispatch_insert_new_cell<Concrete>( cell: Cell, input: Concrete, storage: &mut Self::Storage, )

where Concrete: 'static + Computation + Any, Concrete::Storage: 'static,

impl<T: Debug> Debug for Intermediate<T>

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

Formats the value using the given formatter.

impl<T: Default> Default for Intermediate<T>

fn default() -> Intermediate<T>

Returns the “default value” for a type.

impl<T: Hash> Hash for Intermediate<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: Ord> Ord for Intermediate<T>

fn cmp(&self, other: &Intermediate<T>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<T: PartialEq> PartialEq for Intermediate<T>

fn eq(&self, other: &Intermediate<T>) -> 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<T: PartialOrd> PartialOrd for Intermediate<T>

fn partial_cmp(&self, other: &Intermediate<T>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T: Copy> Copy for Intermediate<T>

impl<T: Eq> Eq for Intermediate<T>

impl<T> StructuralPartialEq for Intermediate<T>