pub fn async<T>() -> (Sender<T>, Receiver<T>) {
    let send = Channel::new(0, true);
    let recv = send.clone();
    (send.into_sender(), recv.into_receiver())
}
/// Create an asynchronous channel with an unbounded buffer.
///
/// Since the buffer is unbounded, send operations always succeed immediately.
///
/// Receive operations succeed only when there is at least one value in the
/// buffer.
///
/// Values are guaranteed to be received in the same order that they are sent.
///
/// The send and receive values returned can be cloned arbitrarily (i.e.,
/// multi-producer/multi-consumer) and moved to other threads.
///
/// When all senders are dropped, the channel is closed automatically. No
/// more values may be sent on a closed channel. Once a channel is closed and
/// the buffer is empty, all receive operations return `None` immediately.
/// (If a channel is closed and there are still values in the buffer, then
/// receive operations will retrieve those first.)
///
/// When all receivers are dropped, no special action is taken. When the buffer
/// is full, all subsequent send operations will block indefinitely.
///
/// # Example
///
/// Asynchronous channels are nice when you just want to enqueue a bunch
/// of values up front:
///
/// ```
/// let (s, r) = chan::async();
///
/// for i in 0..10 {
///     s.send(i);
/// }
///
/// drop(s); // closing the channel lets the iterator stop
/// let numbers: Vec<i32> = r.iter().collect();
/// assert_eq!(numbers, (0..10).collect::<Vec<i32>>());
/// ```
///
/// (Others should help me come up with more compelling examples of
/// asynchronous channels.)
Create an asynchronous channel with an unbounded buffer.
Since the buffer is unbounded, send operations always succeed immediately.

Receive operations succeed only when there is at least one value in the
buffer.

Values are guaranteed to be received in the same order that they are sent.

The send and receive values returned can be cloned arbitrarily  and moved to other threads.

When all senders are dropped, the channel is closed automatically. No
more values may be sent on a closed channel. Once a channel is closed and
the buffer is empty, all receive operations return `None` immediately.
(If a channel is closed and there are still values in the buffer, then
receive operations will retrieve those first.)

When all receivers are dropped, no special action is taken. When the buffer
is full, all subsequent send operations will block indefinitely.
Create an asynchronous channel with an unbounded buffer . Since the buffer is unbounded send operations always succeed immediately . Receive operations succeed only when there is at least one value in the buffer . Values are guaranteed to be received in the same order that they are sent . The send and receive values returned can be cloned arbitrarily and moved to other threads . When all senders are dropped the channel is closed automatically . No more values may be sent on a closed channel . Once a channel is closed and the buffer is empty all receive operations return ` None ` immediately . ( If a channel is closed and there are still values in the buffer then receive operations will retrieve those first . ) When all receivers are dropped no special action is taken . When the buffer is full all subsequent send operations will block indefinitely .
pub fn async<T>() -> (Sender<T>, Receiver<T>) {
    let send = Channel::new(0, true);
    let recv = send.clone();
    (send.into_sender(), recv.into_receiver())
}
pub fn async < T > ( ) -> ( Sender < T > , Receiver < T > ) { let send = Channel :: new ( 0 , true ) ; let recv = send . clone ( ) ; ( send . into_sender ( ) , recv . into_receiver ( ) ) }
Create an asynchronous channel with an unbounded buffer.
Create an asynchronous channel with an unbounded buffer .
example
Asynchronous channels are nice when you just want to enqueue a bunch
of values up front.





drop(s); // closing the channel lets the iterator stop
let numbers: Vec = r.iter().collect();
assert_eq!(numbers, (0..10).collect::>());
```

(Others should help me come up with more compelling examples of
asynchronous channels.)
Asynchronous channels are nice when you just want to enqueue a bunch of values up front . drop ( s ) ; // closing the channel lets the iterator stop let numbers : Vec = r . iter () . collect () ; assert_eq! ( numbers ( 0 .. 10 ) . collect :: > () ) ; ` ` ` ( Others should help me come up with more compelling examples of asynchronous channels . )