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

examples/echo.rs

@@ -9,8 +9,9 @@ use std::net::SocketAddr;
 
 use futures::Future;
 use futures::stream::Stream;
-use tokio_core::Loop;
 use tokio_core::io::{copy, TaskIo};
+use tokio_core::net::TcpListener;
+use tokio_core::reactor::Core;
 
 fn main() {
     env_logger::init().unwrap();
@@ -18,11 +19,11 @@ fn main() {
     let addr = addr.parse::<SocketAddr>().unwrap();
 
     // Create the event loop that will drive this server
-    let mut l = Loop::new().unwrap();
+    let mut l = Core::new().unwrap();
     let pin = l.pin();
 
     // Create a TCP listener which will listen for incoming connections
-    let server = l.handle().tcp_listen(&addr);
+    let server = TcpListener::bind(&addr, &l.handle());
 
     let done = server.and_then(move |socket| {
         // Once we've got the TCP listener, inform that we have it

examples/sink.rs

@@ -14,14 +14,16 @@ use std::net::SocketAddr;
 use futures::Future;
 use futures::stream::{self, Stream};
 use tokio_core::io::IoFuture;
+use tokio_core::net::{TcpListener, TcpStream};
+use tokio_core::reactor::Core;
 
 fn main() {
     env_logger::init().unwrap();
     let addr = env::args().nth(1).unwrap_or("127.0.0.1:8080".to_string());
     let addr = addr.parse::<SocketAddr>().unwrap();
 
-    let mut l = tokio_core::Loop::new().unwrap();
-    let server = l.handle().tcp_listen(&addr).and_then(|socket| {
+    let mut l = Core::new().unwrap();
+    let server = TcpListener::bind(&addr, &l.handle()).and_then(|socket| {
         socket.incoming().and_then(|(socket, addr)| {
             println!("got a socket: {}", addr);
             write(socket).or_else(|_| Ok(()))
@@ -34,7 +36,7 @@ fn main() {
     l.run(server).unwrap();
 }
 
-fn write(socket: tokio_core::TcpStream) -> IoFuture<()> {
+fn write(socket: TcpStream) -> IoFuture<()> {
     static BUF: &'static [u8] = &[0; 64 * 1024];
     let iter = iter::repeat(()).map(|()| Ok(()));
     stream::iter(iter).fold(socket, |socket, ()| {