Struct SpawnRequestBuilder 

pub struct SpawnRequestBuilder<C: ClosureKind> { /* private fields */ }

A builder for configuring new tasks to spawn.

The builder allows us to set up several different flavors of possible tasks to spawn, with a menu of options as follows:

• A task may or may not have a name.
• A task may or may not have an assigned scheduler role.
• A task may be a sync, or an async closure.
• A task may return a result, or may not return a result.
• The task’s result can be collected synchronously, asynchronously, or not collected at all.

Note that these parameters are not perfectly orthogonal. For example, a task spawned from an async closure can not return a value asynchronously. (This is not a limitation of the approach, rather it’s the API that we explicitly use today.) Also, some parameter combinations do not make sense, for example a spawn request can not have both a sync and an async closure to run.

The builder API is designed in a way that only allows chaining the configuration options which are valid at that point in the configuration process. Invalid option combinations are compile-time(!) errors. It will only allow creating a SpawnRequest if enough parameters have been passed such that there is enough information to create a request. It will not allow passing conflicting parameters: for example, if you already passed one synchronous closure, it is impossible to pass another closure and have the code compile without errors.

Usage

Call SpawnRequestBuilder::new() to start building. Refer to the unit tests in this module for usage examples.

Implementations

impl SpawnRequestBuilder<ClosureNone>

You can only create an empty request builder.

pub fn new() -> Self

Creates a new spawn request builder.

impl<C: ClosureKind> SpawnRequestBuilder<C>

You can call these at any point in the builder’s lifecycle.

pub fn with_role(self, role: &'static str) -> Self

Set a role to apply to the thread that will run your closure.

pub fn with_debug_name(self, debug_name: &'static str) -> Self

Set a task name to apply to the thread that will run your closure.

impl SpawnRequestBuilder<ClosureNone>

You can call these only if you have not provided a closure yet.

pub fn with_sync_closure<F, T>( self, f: F, ) -> SpawnRequestBuilder<impl FnOnce(&mut Locked<Unlocked>, &CurrentTask) -> T + Send + 'static>

where T: Send + 'static, F: FnOnce(&mut Locked<Unlocked>, &CurrentTask) -> T + Send + 'static,

Provides the closure that the spawner will run.

pub fn with_async_closure<F, T>( self, f: F, ) -> SpawnRequestBuilder<impl FnOnce(&mut Locked<Unlocked>, &CurrentTask) -> T + Send + 'static>

where T: Send + 'static, F: AsyncFnOnce(LockedAndTask<'_>) -> T + Send + 'static,

Provides the closure that the spawner will run.

impl<T, F> SpawnRequestBuilder<F>

where T: Send + 'static, F: FnOnce(&mut Locked<Unlocked>, &CurrentTask) -> T + Send + 'static,

pub fn build(self) -> SpawnRequest

Build a spawn request.

pub fn build_with_sync_result( self, ) -> (impl FnOnce() -> Result<T, Errno>, SpawnRequest)

Like [build], but allows receiving a result synchronously. Do not forget to submit the spawn request to a spawner.

Example:

let (result_fn, request) = /*...*/ .build_with_sync_result();
// spawn `request`
let result = result_fn();

pub fn build_with_async_result( self, ) -> (impl Future<Output = Result<T, Errno>>, SpawnRequest)

Like [build], but allows receiving a result as a future. Do not forget to submit the spawn request to a spawner.

Example:

let (result_fut, request) = /*...*/ .build_with_async_result();
// spawn `request`
let result = result_fut.await;