Struct Receiver 

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

Receiver for one-shot value transfer

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

一次性值传递的接收器

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

Examples

Basic usage

use lite_sync::oneshot::generic::Sender;
 
let (sender, receiver) = Sender::<String>::new();
 
tokio::spawn(async move {
    sender.send("Hello, World!".to_string()).unwrap();
});
 
// Direct await via Future impl
let message = receiver.await;
assert_eq!(message, "Hello, World!");

Awaiting on mutable reference

use lite_sync::oneshot::generic::Sender;
 
let (sender, mut receiver) = Sender::<i32>::new();
 
tokio::spawn(async move {
    sender.send(42).unwrap();
});
 
// Can also await on &mut receiver
let value = (&mut receiver).await;
assert_eq!(value, 42);

Implementations

impl<T> Receiver<T>

pub async fn wait(self) -> T

Wait for value asynchronously

This is equivalent to using .await directly on the receiver

异步等待值

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

Returns

Returns the received value

返回值

返回接收到的值

pub fn try_recv(&mut self) -> Option<T>

Try to receive a value without blocking

Returns None if no value has been sent yet

尝试接收值而不阻塞

如果还没有发送值则返回 None

Trait Implementations

impl<T> Debug for Receiver<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T> 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 value already sent (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> Unpin for Receiver<T>