Reorganize the entire crate:

Renamed APIs

* Loop => reactor::Core
* LoopHandle => reactor::Handle
* LoopPin => reactor::Pinned
* TcpStream => net::TcpStream
* TcpListener => net::TcpListener
* UdpSocket => net::UdpSocket
* Sender => channel::Sender
* Receiver => channel::Receiver
* Timeout => reactor::Timeout
* ReadinessStream => reactor::PollEvented
* All `LoopHandle` methods to construct objects are now free functions on the
  associated types, e.g. `LoopHandle::tcp_listen` is now `TcpListener::bind`
* All APIs taking a `Handle` now take a `Handle` as the last argument
* All future-returning APIs now return concrete types instead of trait objects

Added APIs

* io::Io trait -- Read + Write + ability to poll

Removed without replacement:

* AddSource
* AddTimeout
* IoToken
* TimeoutToken

Closes #3
Closes #6

src/channel.rs

@@ -1,3 +1,8 @@
+//! In-memory evented channels.
+//!
+//! This module contains a `Sender` and `Receiver` pair types which can be used
+//! to send messages between different future tasks.
+
 use std::io;
 use std::sync::mpsc::TryRecvError;
 
@@ -5,15 +10,15 @@ use futures::{Future, Poll, Async};
 use futures::stream::Stream;
 use mio::channel;
 
-use {ReadinessStream, LoopHandle};
 use io::IoFuture;
+use reactor::{Handle, PollEvented};
 
 /// The transmission half of a channel used for sending messages to a receiver.
 ///
 /// A `Sender` can be `clone`d to have multiple threads or instances sending
 /// messages to one receiver.
 ///
-/// This type is created by the `LoopHandle::channel` method.
+/// This type is created by the `channel` function.
 pub struct Sender<T> {
     tx: channel::Sender<T>,
 }
@@ -24,32 +29,36 @@ pub struct Sender<T> {
 /// A `Receiver` cannot be cloned, so only one thread can receive messages at a
 /// time.
 ///
-/// This type is created by the `LoopHandle::channel` method and implements the
-/// `Stream` trait to represent received messages.
+/// This type is created by the `channel` function and implements the `Stream`
+/// trait to represent received messages.
 pub struct Receiver<T> {
-    rx: ReadinessStream<channel::Receiver<T>>,
+    rx: PollEvented<channel::Receiver<T>>,
 }
 
-impl LoopHandle {
-    /// Creates a new in-memory channel used for sending data across `Send +
-    /// 'static` boundaries, frequently threads.
-    ///
-    /// This type can be used to conveniently send messages between futures.
-    /// Unlike the futures crate `channel` method and types, the returned tx/rx
-    /// pair is a multi-producer single-consumer (mpsc) channel *with no
-    /// backpressure*. Currently it's left up to the application to implement a
-    /// mechanism, if necessary, to avoid messages piling up.
-    ///
-    /// The returned `Sender` can be used to send messages that are processed by
-    /// the returned `Receiver`. The `Sender` can be cloned to send messages
-    /// from multiple sources simultaneously.
-    pub fn channel<T>(self) -> (Sender<T>, IoFuture<Receiver<T>>)
-        where T: Send + 'static,
-    {
-        let (tx, rx) = channel::channel();
-        let rx = ReadinessStream::new(self, rx).map(|rx| Receiver { rx: rx });
-        (Sender { tx: tx }, rx.boxed())
-    }
+/// Future returned by the `channel` function which will resolve to a
+/// `Receiver<T>`.
+pub struct ReceiverNew<T> {
+    inner: IoFuture<Receiver<T>>,
+}
+
+/// Creates a new in-memory channel used for sending data across `Send +
+/// 'static` boundaries, frequently threads.
+///
+/// This type can be used to conveniently send messages between futures.
+/// Unlike the futures crate `channel` method and types, the returned tx/rx
+/// pair is a multi-producer single-consumer (mpsc) channel *with no
+/// backpressure*. Currently it's left up to the application to implement a
+/// mechanism, if necessary, to avoid messages piling up.
+///
+/// The returned `Sender` can be used to send messages that are processed by
+/// the returned `Receiver`. The `Sender` can be cloned to send messages
+/// from multiple sources simultaneously.
+pub fn channel<T>(handle: &Handle) -> (Sender<T>, ReceiverNew<T>)
+    where T: Send + 'static,
+{
+    let (tx, rx) = channel::channel();
+    let rx = PollEvented::new(rx, handle).map(|rx| Receiver { rx: rx });
+    (Sender { tx: tx }, ReceiverNew { inner: rx.boxed() })
 }
 
 impl<T> Sender<T> {
@@ -87,7 +96,9 @@ impl<T> Stream for Receiver<T> {
     type Error = io::Error;
 
     fn poll(&mut self) -> Poll<Option<T>, io::Error> {
-        try_ready!(self.rx.poll_read());
+        if let Async::NotReady = self.rx.poll_read() {
+            return Ok(Async::NotReady)
+        }
         match self.rx.get_ref().try_recv() {
             Ok(t) => Ok(Async::Ready(Some(t))),
             Err(TryRecvError::Empty) => {
@@ -98,3 +109,12 @@ impl<T> Stream for Receiver<T> {
         }
     }
 }
+
+impl<T> Future for ReceiverNew<T> {
+    type Item = Receiver<T>;
+    type Error = io::Error;
+
+    fn poll(&mut self) -> Poll<Receiver<T>, io::Error> {
+        self.inner.poll()
+    }
+}