Tasks

#[nuclei::main]
async fn main() {
    // Each task is placed on a shard, and there it stays.
    let tasks: Vec<_> = (0..8u64)
        .map(|n| nuclei::spawn(async move { n * n }))
        .collect();

    let mut total = 0;
    for task in tasks {
        total += task.await;
    }
    assert_eq!(total, 140);
}

use std::time::Duration;

use nuclei::time::sleep;

#[nuclei::main]
async fn main() {
    // Dropping a Task cancels it: this one never prints.
    let dropped = nuclei::spawn(async {
        sleep(Duration::from_millis(50)).await;
        println!("never printed");
    });
    drop(dropped);

    // detach lets a task run to its end with no handle.
    nuclei::spawn(async { println!("detached, and it runs") }).detach();

    // cancel stops a task, and gives its output back if it had finished.
    let slow = nuclei::spawn(async {
        sleep(Duration::from_secs(10)).await;
        1
    });
    assert_eq!(slow.cancel().await, None);

    // abort cancels without waiting; an AbortHandle does it from anywhere.
    let stuck = nuclei::spawn(std::future::pending::<()>());
    let abort = stuck.abort_handle();
    abort.abort();
    assert!(stuck.join().await.unwrap_err().is_cancelled());

    sleep(Duration::from_millis(100)).await;
}

#[nuclei::main]
async fn main() {
    // join gives the output, or a JoinError that says why there is none.
    let ok = nuclei::spawn(async { 7 }).join().await;
    assert_eq!(ok.unwrap(), 7);

    let failed = nuclei::spawn(async {
        if true {
            panic!("the task gave up");
        }
    })
    .join()
    .await;
    let error = failed.unwrap_err();
    assert!(error.is_panic());
    let message = error.into_panic();
    assert_eq!(message.downcast_ref::<&str>(), Some(&"the task gave up"));

    // fallible: None where awaiting the Task would panic.
    let done = nuclei::spawn(async { 1 }).fallible();
    assert_eq!(done.await, Some(1));
}

use std::time::Duration;

use nuclei::task::JoinSet;
use nuclei::time::sleep;

#[nuclei::main]
async fn main() {
    let mut set = JoinSet::new();
    for n in [30u64, 10, 20] {
        set.spawn(async move {
            sleep(Duration::from_millis(n)).await;
            n
        });
    }
    // Joined in the order they finish, not the order they were spawned.
    let mut order = Vec::new();
    while let Some(done) = set.join_next().await {
        order.push(done.unwrap());
    }
    assert_eq!(order, [10, 20, 30]);

    // Dropping the set, or shutdown, cancels whatever is still in it.
    set.spawn(std::future::pending());
    set.shutdown().await;
    assert!(set.is_empty());
}

use nuclei::task;

#[nuclei::main]
async fn main() -> std::io::Result<()> {
    // A task spawned with options: a name.
    let worker = task::Builder::new()
        .name("checksum")
        .spawn(async { task::id() })?;
    let id = worker.id();

    // Inside the task, task::id() is the same id the handle reports.
    assert_eq!(worker.await, id);
    // Outside any task there is none.
    assert!(task::try_id().is_none());
    Ok(())
}

use std::cell::RefCell;
use std::rc::Rc;

#[nuclei::main]
async fn main() {
    // Rc is not Send: these tasks stay on the thread that spawned them.
    let log = Rc::new(RefCell::new(Vec::new()));
    let tasks: Vec<_> = (0..3)
        .map(|n| {
            let log = Rc::clone(&log);
            nuclei::spawn_local(async move { log.borrow_mut().push(n) })
        })
        .collect();
    for task in tasks {
        task.await;
    }
    assert_eq!(log.borrow().len(), 3);
}

#[nuclei::main]
async fn main() -> std::io::Result<()> {
    // Blocking calls go to the blocking pool, so no shard waits on them.
    let entries = nuclei::spawn_blocking(|| std::fs::read_dir(".").map(|dir| dir.count())).await?;
    println!("{entries} entries here");

    let digest =
        nuclei::spawn_blocking(|| (0..1_000_000u64).fold(0u64, |h, n| h.rotate_left(5) ^ n)).await;
    println!("digest {digest:x}");
    Ok(())
}

nuclei::task_local! {
    static REQUEST: u64;
}

async fn handle() -> String {
    // Any code the task runs reads the value its scope set.
    format!("request {}", REQUEST.get())
}

#[nuclei::main]
async fn main() {
    let first = nuclei::spawn(REQUEST.scope(1, handle()));
    let second = nuclei::spawn(REQUEST.scope(2, handle()));
    assert_eq!(first.await, "request 1");
    assert_eq!(second.await, "request 2");

    // Read where no scope set it, try_with answers an error instead of panicking.
    assert!(REQUEST.try_with(|id| *id).is_err());
}

use nuclei::task::{self, coop};

#[nuclei::main]
async fn main() {
    let busy = nuclei::spawn(async {
        let mut sum = 0u64;
        for n in 0..100_000u64 {
            sum += n;
            // A long loop that awaits nothing else spends the budget, so the
            // shard's other tasks get their turns.
            coop::consume_budget().await;
        }
        sum
    });
    // yield_now: a turn for the other tasks of this shard, at once.
    task::yield_now().await;
    assert_eq!(busy.await, 4_999_950_000);
}