Struct BoxRunnableWith 

pub struct BoxRunnableWith<T, E> { /* private fields */ }

Box-based runnable with mutable input.

BoxRunnableWith<T, E> stores a Box<dyn FnMut(&mut T) -> Result<(), E>> and can be called repeatedly.

Author

Haixing Hu

Implementations

impl<T, E> BoxRunnableWith<T, E>

pub fn new<F>(function: F) -> Self

where F: FnMut(&mut T) -> Result<(), E> + 'static,

Creates a new runnable-with.

Wraps the provided closure in the appropriate smart pointer type for this runnable-with implementation.

Examples found in repository

examples/tasks/task_demo.rs (lines 65-68)

fn demo_mutable_input_tasks() {
    println!("--- Mutable-input tasks ---");

    let mut state = 40;
    let mut callable = BoxCallableWith::new(|input: &mut i32| {
        *input += 2;
        Ok::<i32, String>(*input)
    });
    println!("CallableWith result: {:?}", callable.call_with(&mut state));
    println!("State after CallableWith: {state}");

    let mut runnable = BoxRunnableWith::new(|input: &mut i32| {
        *input *= 2;
        Ok::<(), String>(())
    });
    println!("RunnableWith result: {:?}", runnable.run_with(&mut state));
    println!("State after RunnableWith: {state}");
    println!();
}

pub fn new_with_name<F>(name: &str, function: F) -> Self

where F: FnMut(&mut T) -> Result<(), E> + 'static,

Creates a new named runnable-with.

Wraps the provided closure and assigns it a name, which is useful for debugging and logging purposes.

pub fn new_with_optional_name<F>(function: F, name: Option<String>) -> Self

where F: FnMut(&mut T) -> Result<(), E> + 'static,

Creates a new named runnable-with with an optional name.

Wraps the provided closure and assigns it an optional name.

pub fn name(&self) -> Option<&str>

Gets the name of this runnable-with.

Returns

Returns Some(&str) if a name was set, None otherwise.

pub fn set_name(&mut self, name: &str)

Sets the name of this runnable-with.

Parameters

• name - The name to set for this runnable-with

pub fn clear_name(&mut self)

Clears the name of this runnable-with.

pub fn and_then<N>(self, next: N) -> BoxRunnableWith<T, E>

where N: RunnableWith<T, E> + 'static, T: 'static, E: 'static,

Chains another runnable after this runnable succeeds.

Parameters

• next - The runnable to execute after this runnable succeeds.

Returns

A runnable executing both actions in sequence.

pub fn then_callable_with<R, C>(self, callable: C) -> BoxCallableWith<T, R, E>

where C: CallableWith<T, R, E> + 'static, T: 'static, R: 'static, E: 'static,

Runs this runnable before a callable.

The callable is not executed if this runnable returns Err.

Parameters

• callable - The callable to execute after this runnable succeeds.

Returns

A callable producing the second computation’s result.

Trait Implementations

impl<T, E> Debug for BoxRunnableWith<T, E>

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

Formats the value using the given formatter.

impl<T, E> Display for BoxRunnableWith<T, E>

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

Formats the value using the given formatter.

impl<T, E> RunnableWith<T, E> for BoxRunnableWith<T, E>

fn run_with(&mut self, input: &mut T) -> Result<(), E>

Executes the boxed runnable with mutable input.

fn into_callable_with(self) -> BoxCallableWith<T, (), E>

where Self: Sized + 'static,

Converts this boxed runnable into a boxed callable while preserving its name.

fn into_box(self) -> BoxRunnableWith<T, E>

Converts this runnable into a boxed runnable.

fn into_rc(self) -> RcRunnableWith<T, E>

where Self: 'static,

Converts this runnable into an Rc runnable.

fn into_fn(self) -> impl FnMut(&mut T) -> Result<(), E>

Converts this runnable into a mutable closure.

fn into_arc(self) -> ArcRunnableWith<T, E>

where Self: Sized + Send + 'static,

Converts this runnable into an Arc runnable.