byor 1.0.0

Bring your own runtime!
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79

//! A multi-producer, single-consumer queue for sending values between asynchronous tasks.

use std::error::Error;

use futures_lite::Stream;

/// Base sender behavior for both unbounded and bounded channels.
pub trait Sender<T: 'static>: Clone {
    type SendError: Error;

    /// Returns whether the channel is closed.
    fn is_closed(&self) -> bool;
}

/// More extensive behavior for `Sender` implemented by tokio and futures (that is, only _not_
/// implemented by smol).
pub trait SenderExt<T: 'static>: Sender<T> {
    /// Completes when the receiver has closed.
    fn closed(&mut self) -> impl Future<Output = ()>;

    /// Checks whether the given channel sends to the same receiver as this channel.
    fn same_channel(&self, other: &Self) -> bool;
}

/// A sender to a channel with a maximum capacity.
pub trait BoundedSender<T: 'static>: Sender<T> {
    type TrySendError: Error;

    /// Sends message, waiting until there is capacity.
    ///
    /// Returns `Err` with the given value if the channel is closed.
    fn send(&mut self, message: T) -> impl Future<Output = Result<(), Self::SendError>>;

    /// Attempts to immediately send a message on the channel.
    fn try_send(&mut self, message: T) -> Result<(), Self::TrySendError>;
}

/// Receiver behavior for both unbounded and bounded channels.
pub trait Receiver<T: 'static>: Stream<Item = T> {
    type TryRecvError: Error;

    /// Closes the channel, preventing any further messages from being sent.
    ///
    /// This allows the receiver to halt incoming messages while being able to drain any pending
    /// ones.
    fn close(&mut self);

    /// Tries to immediately receive a message from the channel.
    ///
    /// Returns `Ok(T)` if it can receive a message, `Ok(None)` if the channel is empty, and `Err`
    /// if the channel is closed.
    fn try_recv(&mut self) -> Result<Option<T>, Self::TryRecvError>;
}

/// A sender to a channel without a maximum capacity.
pub trait UnboundedSender<T: 'static>: Sender<T> {
    /// Sends a message.
    ///
    /// Note that this is not marked as async—this method will never block because the channel will
    /// never be full.
    ///
    /// Returrns `Err` with the given value if the channel is closed.
    fn send(&self, message: T) -> Result<(), Self::SendError>;
}

/// A runtime with an MPSC channel.
pub trait RuntimeMpsc {
    type BoundedSender<T: 'static>: BoundedSender<T>;
    type BoundedReceiver<T: 'static>: Receiver<T>;

    fn bounded_channel<T: 'static>(
        buffer: usize,
    ) -> (Self::BoundedSender<T>, Self::BoundedReceiver<T>);

    type UnboundedSender<T: 'static>: UnboundedSender<T>;
    type UnboundedReceiver<T: 'static>: Receiver<T>;

    fn unbounded_channel<T: 'static>() -> (Self::UnboundedSender<T>, Self::UnboundedReceiver<T>);
}