Crate switch_resume

switch-resume

This crates provides functionality for running switchable tasks (futures).

Switching is a control flow mechanism that pauses normal execution of current task, captures current continuation and passes it as an argument to the provided async fn. The task then proceeds by evaluating that fn, instead of resuming normally.

In order to resume normal execution, the passed resumption object can be called explicitly.

This is an implementation of delimited continuations in Rust using async that works on stable.

Examples

fn main() {
    futures::executor::block_on(async {
        switch_resume::run(|task| async move {
            println!("begin");
            task.switch(|resume| async move {
                println!("before");
                resume(()).await;
                println!("after");
            })
            .await;
            println!("end");
        })
        .await;
    });
    // begin
    // before
    // end
    // after
}

fn main() {
    futures::executor::block_on(async {
        async fn bar(resume: switch_resume::Resume<'_, i32, i32>) -> i32 {
            println!("foo has been paused, started bar");
            let resume_result = resume(69).await;
            assert_eq!(resume_result, -1); // This is the result of foo
            420 // This is the final result of task
        }
        async fn foo(task: switch_resume::Task<'_, i32>) -> i32 {
            println!("foo started");
            let value = task.switch(bar).await;
            println!("foo was resumed with {value}. Nice!");
            -1 // This is not the final task result since we switched to bar
        }
        let task_result = switch_resume::run(foo).await;
        assert_eq!(task_result, 420);
    });
}

Structs

Task

Handle to the running task.

Functions

run

Run a task with switch capability.

Type Aliases

Resume

Async function passed to Task::switch. Represents the paused continuation.