Struct Delegate

pub struct Delegate<T> { /* private fields */ }

Delegate or lend an object to another task.

This struct can be used to lend a &mut T to another task on the same executor. The other task can then call a closure on it. After that, the &mut T is returned to the original task.

Under the hood, Delegate leverages [SendCell] to ensure the delegated object stays on the same executor.

Example:

static SOME_VALUE: Delegate<u32> = Delegate::new();

// in some task
async fn foo() {
  let mut my_val = 0u32;
  SOME_VALUE.lend(&mut my_val).await;
  assert_eq!(my_val, 1);
}

// in some other task
async fn bar() {
  SOME_VALUE.with(|val| *val = 1).await;
}

TODO: this is a PoC implementation.

• takes 24b for each delegate (on arm), which seems too much.
• doesn’t protect at all against calling lend() or with() multiple times each, breaking safety assumptions. So while the API seems OK, the implementation needs work.

Implementations

impl<T> Delegate<T>

pub const fn new() -> Delegate<T>

Creates a new Delegate.

pub async fn lend<'a, 'b>(&'a self, something: &'b mut T)

where 'b: 'a,

Lends an object.

This blocks until another task called with().

pub async fn with<U>(&self, func: impl FnOnce(&mut T) -> U) -> U

Calls a closure on a lended object.

This blocks until another task called lend(something).

Trait Implementations

impl<T> Default for Delegate<T>

where T: Default,

fn default() -> Delegate<T>

Returns the “default value” for a type.