Struct tange::deferred::Deferred

pub struct Deferred<A> { /* private fields */ }

A Deferred is the core struct defining how computations are composed The type parameter indicates the type of data contained within the Deferred

Implementations

impl<A: Any + Send + Sync> Deferred<A>

pub fn apply<B: Any + Send + Sync, F: Send + Sync + 'static + Fn(&A) -> B>(
    &self,
    f: F
) -> Deferred<B>

Applies a function to a Deferred, returning a new Deferred. This is effectively a Functor.

use tange::deferred::Deferred;
use tange::scheduler::GreedyScheduler;

let def = Deferred::lift(vec![1u8, 2, 3, 4], "Vector".into());
let size = def.apply(|v| v.len());
let results = size.run(&GreedyScheduler::new());
assert_eq!(results, Some(4usize));

pub fn join<B: Any + Send + Sync, C: Any + Send + Sync, F: Send + Sync + 'static + Fn(&A, &B) -> C>(
    &self,
    other: &Deferred<B>,
    f: F
) -> Deferred<C>

Joins two Deferred objects with a function, creating a new Deferred object.

use tange::deferred::Deferred;
use tange::scheduler::GreedyScheduler;

let left  = Deferred::lift(vec![1f32, 2., 3., 4.], "Vector".into());
let right  = Deferred::lift(10f32, "Num".into());
let multiplied: Deferred<Vec<f32>> = left.join(&right, 
       |l,r| l.iter().map(|x| x * r).collect());
let results = multiplied.run(&GreedyScheduler::new());
assert_eq!(results, Some(vec![10., 20., 30., 40.]));

impl<A: Any + Send + Sync + Clone> Deferred<A>

pub fn lift(a: A, name: Option<&str>) -> Self

Lifts a value into a Deferred object.

use tange::deferred::Deferred;
use tange::scheduler::GreedyScheduler;

let id = Deferred::lift("Some String".to_owned(), "String".into());
assert_eq!(id.run(&GreedyScheduler::new()), Some("Some String".into()));
 

pub fn run<S: Scheduler>(&self, s: &S) -> Option<A>

Evaluates the Deferred object and dependency graph, returning the result of the computation.

use tange::deferred::Deferred;
use tange::scheduler::GreedyScheduler;

let a = Deferred::lift(1usize, "a".into());
let b = Deferred::lift(2usize, "b".into());
let c = a.join(&b, |x, y| x + y);
assert_eq!(c.run(&GreedyScheduler::new()), Some(3usize));
 

Trait Implementations

impl<A: Clone> Clone for Deferred<A>

fn clone(&self) -> Deferred<A>

Returns a copy of the value.

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

Performs copy-assignment from source.