Struct Computation 

pub struct Computation<CONTEXT, STATE, OUTPUT, STEP: ComputationStep<CONTEXT, STATE, OUTPUT>> { /* private fields */ }

A stateful computation that can be suspended and resumed.

Computation is the default implementation of Algorithm. It delegates the actual computation logic to a ComputationStep implementation while handling the boilerplate of state management and cancellation checking.

Type Parameters

• CONTEXT: Immutable configuration passed to each step
• STATE: Mutable state that persists across steps
• OUTPUT: The final result type
• STEP: The ComputationStep implementation that defines the computation logic

Example

use computation_process::{Computation, ComputationStep, Completable, Incomplete, Computable, Stateful};

struct SumStep;

impl ComputationStep<Vec<i32>, usize, i32> for SumStep {
    fn step(numbers: &Vec<i32>, index: &mut usize) -> Completable<i32> {
        if *index < numbers.len() {
            *index += 1;
            Err(Incomplete::Suspended) // Suspend after processing each number
        } else {
            Ok(numbers.iter().sum())
        }
    }
}

let mut computation = Computation::<Vec<i32>, usize, i32, SumStep>::from_parts(
    vec![1, 2, 3, 4, 5],
    0,
);
assert_eq!(computation.compute().unwrap(), 15);

Trait Implementations

impl<CONTEXT, STATE, OUTPUT, STEP: ComputationStep<CONTEXT, STATE, OUTPUT>> Algorithm<CONTEXT, STATE, OUTPUT> for Computation<CONTEXT, STATE, OUTPUT, STEP>

fn run<I1: Into<CONTEXT>, I2: Into<STATE>>( context: I1, initial_state: I2, ) -> Cancellable<OUTPUT>

where Self: Sized + 'static,

Configure and immediately execute the computation, skipping over all suspended states.

fn dyn_algorithm(self) -> DynAlgorithm<CONTEXT, STATE, OUTPUT>

where Self: Sized + 'static,

Convert to a dynamic Algorithm variant.

impl<CONTEXT, STATE, OUTPUT, STEP: ComputationStep<CONTEXT, STATE, OUTPUT>> Computable<OUTPUT> for Computation<CONTEXT, STATE, OUTPUT, STEP>

fn try_compute(&mut self) -> Completable<OUTPUT>

Try to advance this computation, returning a value once the computation is done.

fn compute_completable(&mut self) -> Completable<T>

Advance this computation until it either completes, is canceled, or becomes exhausted, skipping over all suspended states.

fn compute(&mut self) -> Cancellable<T>

Advance this computation until completion, skipping over all suspended states.

fn dyn_computable(self) -> DynComputable<T>

where Self: Sized + 'static,

Utility method to convert this Computable to a dynamic type.

impl<CONTEXT: Debug, STATE: Debug, OUTPUT: Debug, STEP: Debug + ComputationStep<CONTEXT, STATE, OUTPUT>> Debug for Computation<CONTEXT, STATE, OUTPUT, STEP>

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

Formats the value using the given formatter.

impl<'de, CONTEXT, STATE, OUTPUT, STEP: ComputationStep<CONTEXT, STATE, OUTPUT>> Deserialize<'de> for Computation<CONTEXT, STATE, OUTPUT, STEP>

where CONTEXT: Serialize + for<'a> Deserialize<'a>, STATE: Serialize + for<'a> Deserialize<'a>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<CONTEXT, STATE, OUTPUT, STEP: ComputationStep<CONTEXT, STATE, OUTPUT>> Serialize for Computation<CONTEXT, STATE, OUTPUT, STEP>

where CONTEXT: Serialize + for<'a> Deserialize<'a>, STATE: Serialize + for<'a> Deserialize<'a>,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<CONTEXT, STATE, OUTPUT, STEP: ComputationStep<CONTEXT, STATE, OUTPUT>> Stateful<CONTEXT, STATE> for Computation<CONTEXT, STATE, OUTPUT, STEP>

fn from_parts(context: CONTEXT, state: STATE) -> Self

where Self: Sized + 'static,

Create new Stateful instance from CONTEXT and STATE.

fn into_parts(self) -> (CONTEXT, STATE)

Destruct the Stateful instance into CONTEXT and STATE objects.

fn context(&self) -> &CONTEXT

Access to the underlying immutable CONTEXT.

fn state(&self) -> &STATE

Access to the underlying STATE.

fn state_mut(&mut self) -> &mut STATE

Access to the underlying STATE as a mutable reference.

fn configure<I1: Into<CONTEXT>, I2: Into<STATE>>( context: I1, initial_state: I2, ) -> Self

where Self: Sized + 'static,

Create new Stateful instance using values that can be converted to CONTEXT and STATE.