No more need for lazy in chat example

examples/chat.rs

@@ -37,6 +37,7 @@ fn main() {
 
     let srv = socket.incoming().for_each(move |(stream, addr)| {
         println!("New Connection: {}", addr);
+        let (reader, writer) = stream.split();
 
         // Create a channel for our stream, which other sockets will use to
         // send us messages. Then register our address with the stream to send
@@ -44,19 +45,10 @@ fn main() {
         let (tx, rx) = tokio_core::channel::channel(&handle).unwrap();
         connections.borrow_mut().insert(addr, tx);
 
-        // Note that below we're calling `spawn` to spawn a new future for this
-        // connection. As a result we use `futures::lazy` here to ensure that
-        // the call to `.split()` happens on the right task.
-        //
-        // This `split` will give us a read/write half to work with each portion
-        // of the socket separately.
-        let pair = futures::lazy(|| Ok(stream.split()));
-
         // Define here what we do for the actual I/O. That is, read a bunch of
         // lines from the socket and dispatch them while we also write any lines
         // from other sockets.
         let connections_inner = connections.clone();
-        let pair = pair.map(move |(reader, writer)| {
         let reader = BufReader::new(reader);
 
         // Model the read portion of this socket by mapping an infinite
@@ -108,20 +100,12 @@ fn main() {
             amt
         });
 
-            (socket_reader, socket_writer)
-        });
-
         // Now that we've got futures representing each half of the socket, we
         // use the `select` combinator to wait for either half to be done to
         // tear down the other. Then we spawn off the result.
         let connections = connections.clone();
-        let addr = addr;
+        let connection = socket_reader.map(|_| ()).select(socket_writer.map(|_| ()));
-        handle.spawn(pair.and_then(|(reader, writer)| {
+        handle.spawn(connection.then(move |_| {
-            let reader = reader.map(|_| ());
-            let writer = writer.map(|_| ());
-
-            reader.select(writer)
-        }).then(move |_| {
             connections.borrow_mut().remove(&addr);
             println!("Connection {} closed.", addr);
             Ok(())