Struct Answer

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

An answer to a completed Future.

The are two times we need to wait on a future running to completion: the outer initial executor invocation from the main thread, and running an async thread which will have a join method.

For both cases, we will use a Semaphore to indicate when the data is available.

The main issue is that this type is intended to be one shot. Trying to load a second value will invalidate the data structure (the item will be replaced, but there is a race with the semaphore).

TODO: Currently, the data is stored inside of a Mutex. This isn’t actually necessary (the semaphore already manages the coordination), and only a memory barrier would be needed, which would be provided by the semaphore. So, this should be changed to just unsafely share the data, similar to how a mutex is implemented.

Implementations

impl<T> Answer<T>

pub fn new() -> Self

Construct a new Answer that does not have the result.

pub fn place(&self, item: T)

Place the item into the Answer.

Panic

If the answer already contains an item, this will panic.

TODO

We could check that the Answer has ever been used, not just that it has an answer in it.

pub fn take(&self) -> T

Synchronously wait for an Answer.

Blocks the current thread until an answer is available, returning it.

pub async fn take_async(&self) -> T

Asynchronously wait for an answer.