Struct TaskBuilder

Source

pub struct TaskBuilder<'a, Tk: Task, Deps> { /* private fields */ }

Expand description

Node builder that tracks dependency completion via type state.

A TaskBuilder<Tk, Deps> is returned from DagRunner::add_task and uses the type-state pattern to ensure dependencies are wired correctly at compile time:

TaskBuilder<Tk, Pending>: No dependencies specified yet
TaskBuilder<Tk, Tk::Input>: Dependencies complete; acts as a TaskHandle<Tk::Output>

§Examples

// Using tuple struct for simple constants
struct Constant(i32);

#[task]
impl Constant {
    async fn run(&mut self) -> i32 { self.0 }
}

// Task with state constructed via ::new()
struct Multiplier { factor: i32 }

impl Multiplier {
    fn new(factor: i32) -> Self { Self { factor } }
}

#[task]
impl Multiplier {
    async fn run(&mut self, x: &i32) -> i32 { x * self.factor }
}

let mut dag = DagRunner::new();

// Construct with initial value (tuple struct)
let a = dag.add_task(Constant(10));
// a is TaskBuilder<_, Pending> since no dependencies needed (Input = ())

// Construct with ::new() pattern
let b = dag.add_task(Multiplier::new(2));
// b is TaskBuilder<_, Pending> until we call depends_on()

let b = b.depends_on(&a);
// Now b is a TaskHandle<i32>

dag.run(|fut| { tokio::spawn(fut); }).await.unwrap();
assert_eq!(dag.get(&b).unwrap(), 20);

Implementations§

Source §

impl<'a, Tk: Task, Deps> TaskBuilder<'a, Tk, Deps>

Source

pub fn depends_on<D>(self, deps: D) -> TaskHandle<Tk::Output>
where D: DepsTuple<Tk::Input>,

Provide all dependencies exactly once as a tuple.

The dependencies must match the task’s Input type exactly:

Input = (): Do not call depends_on
Input = T: Pass &TaskHandle or (&TaskHandle,)
Input = (A, B, ...): Pass (&TaskHandle<A>, &TaskHandle, ...)

The order of dependencies in the tuple must match the order in Input.

§Examples

// Tuple struct
struct Value(i32);

#[task]
impl Value {
    async fn run(&mut self) -> i32 { self.0 }
}

// Tuple struct with multiplier
struct Scale(i32);

#[task]
impl Scale {
    async fn run(&mut self, x: &i32) -> i32 { x * self.0 }
}

// Unit struct
struct Add;

#[task]
impl Add {
    async fn run(&mut self, a: &i32, b: &i32) -> i32 { a + b }
}

let dag = DagRunner::new();

let x = dag.add_task(Value(2));
let y = dag.add_task(Value(3));

// Single dependency
let double = dag.add_task(Scale(2)).depends_on(&x);

// Multiple dependencies: tuple form
let sum = dag.add_task(Add).depends_on((&x, &y));

dag.run(|fut| { tokio::spawn(fut); }).await.unwrap();