Struct Receiver 

pub struct Receiver<T: State = TaskCompletion> { /* private fields */ }

Completion receiver for one-shot tasks

Implements Future directly, allowing direct .await usage on both owned values and mutable references

一次性任务完成通知接收器

直接实现了 Future，允许对拥有的值和可变引用都直接使用 .await

Examples

Using default TaskCompletion type

let (notifier, receiver) = Sender::new();
 
tokio::spawn(async move {
    notifier.notify(TaskCompletion::Called);
});
 
// Two equivalent ways to await:
let result = receiver.await;               // Direct await via Future impl
// or
let result = receiver.wait().await;        // Explicit wait method

Awaiting on mutable reference

let (notifier, mut receiver) = Sender::new();
 
tokio::spawn(async move {
    notifier.notify(TaskCompletion::Called);
});
 
// Can also await on &mut receiver
let result = (&mut receiver).await;

Using unit type for simple completion

let (notifier, receiver) = Sender::<()>::new();
 
tokio::spawn(async move {
    // ... do work ...
    notifier.notify(());  // Signal completion
});
 
receiver.await;  // Wait for completion

Using custom state

let (notifier, receiver) = Sender::<CustomState>::new();
 
tokio::spawn(async move {
    notifier.notify(CustomState::Success);
});
 
match receiver.await {
    CustomState::Success => println!("Success!"),
    CustomState::Failure => println!("Failed"),
    CustomState::Timeout => println!("Timed out"),
}

Implementations

impl<T: State> Receiver<T>

pub async fn wait(self) -> T

Wait for task completion asynchronously

This is equivalent to using .await directly on the receiver

异步等待任务完成

这等同于直接在 receiver 上使用 .await

Returns

Returns the completion state

返回值

返回完成状态

Trait Implementations

impl<T: State> Future for Receiver<T>

Direct Future implementation for Receiver

This allows both receiver.await and (&mut receiver).await to work

Optimized implementation:

• Fast path: Immediate return if already completed (no allocation)
• Slow path: Direct waker registration (no Box allocation, just copy two pointers)
• No intermediate future state needed

为 Receiver 直接实现 Future

这允许 receiver.await 和 (&mut receiver).await 都能工作

优化实现：

• 快速路径：如已完成则立即返回（无分配）
• 慢速路径：直接注册 waker（无 Box 分配，只复制两个指针）
• 无需中间 future 状态

type Output = T

The type of value produced on completion.

fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output>

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

impl<T: State> Unpin for Receiver<T>