Struct pasts::Loop

pub struct Loop<S: Unpin, T, F: Stateful<S, T>> { /* private fields */ }

Composable asynchronous event loop.

Selecting on Futures:

Select first completed future.

use async_main::{async_main, LocalSpawner};
use pasts::{prelude::*, Loop};

struct Exit;

struct App<'a> {
    tasks: &'a mut [BoxNotify<'static, &'static str>],
}

impl App<'_> {
    fn completion(&mut self, (id, val): (usize, &str)) -> Poll<Exit> {
        println!("Received message from {id}, completed task: {val}");

        Ready(Exit)
    }
}

#[async_main]
async fn main(_spawner: LocalSpawner) {
    let tasks: &mut [BoxNotify<'_, _>] = &mut [
        Box::pin(async { "Hello" }.fuse()),
        Box::pin(async { "World" }.fuse()),
    ];
    let mut app = App { tasks };

    // First task will complete first.
    Loop::new(&mut app).on(|s| s.tasks, App::completion).await;
}

Task spawning

Spawns tasks in a Vec, and removes them as they complete.

use async_main::{async_main, LocalSpawner};
use pasts::{prelude::*, Loop};

struct Exit;

struct App {
    tasks: Vec<BoxNotify<'static, &'static str>>,
}

impl App {
    fn completion(&mut self, (id, val): (usize, &str)) -> Poll<Exit> {
        println!("Received message from completed task: {val}");

        self.tasks.swap_remove(id);

        if self.tasks.is_empty() {
            Ready(Exit)
        } else {
            Pending
        }
    }
}

#[async_main]
async fn main(_spawner: LocalSpawner) {
    let mut app = App {
        tasks: vec![
            Box::pin(async { "Hello" }.fuse()),
            Box::pin(async { "World" }.fuse()),
        ],
    };

    Loop::new(&mut app)
        .on(|s| &mut s.tasks[..], App::completion)
        .await;
}

Implementations

impl<'a, S: Unpin, T> Loop<S, T, Never<'a, S>>

pub fn new(state: &'a mut S) -> Self

Create an empty event loop.

impl<S: Unpin, T, F: Stateful<S, T>> Loop<S, T, F>

pub fn on<N: Notify + Unpin + ?Sized>( self, noti: impl for<'a> FnMut(&'a mut S) -> &'a mut N + Unpin, then: fn(_: &mut S, _: N::Event) -> Poll<T> ) -> Loop<S, T, impl Stateful<S, T>>

Register an event handler.

Trait Implementations

impl<S: Debug + Unpin, T: Debug, F: Debug + Stateful<S, T>> Debug for Loop<S, T, F>

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

Formats the value using the given formatter.

impl<S: Unpin, T: Unpin, F: Stateful<S, T>> Future for Loop<S, T, F>

type Output = T

The type of value produced on completion.

fn poll(self: Pin<&mut Self>, t: &mut Task<'_>) -> Poll<T>

Attempt to resolve the future to a final value, registering the current task for wakeup if the value is not yet available.