Remove usage of async_closure (#69)

Author: taiki-e

examples/guessing.rs

@@ -63,9 +63,11 @@ async fn main() -> Result<(), failure::Error> {
 
     let incoming = listener.incoming().map_err(|e| e.into());
     incoming
-        .try_for_each_concurrent(None, async move |stream| {
-            runtime::spawn(play(stream)).await?;
-            Ok::<(), failure::Error>(())
+        .try_for_each_concurrent(None, |stream| {
+            async move {
+                runtime::spawn(play(stream)).await?;
+                Ok::<(), failure::Error>(())
+            }
         })
         .await?;
     Ok(())

examples/tcp-echo.rs

@@ -16,15 +16,17 @@ async fn main() -> std::io::Result<()> {
     // accept connections and process them in parallel
     listener
         .incoming()
-        .try_for_each_concurrent(None, async move |stream| {
-            runtime::spawn(async move {
-                println!("Accepting from: {}", stream.peer_addr()?);
+        .try_for_each_concurrent(None, |stream| {
+            async move {
+                runtime::spawn(async move {
+                    println!("Accepting from: {}", stream.peer_addr()?);
 
-                let (reader, writer) = &mut stream.split();
-                reader.copy_into(writer).await?;
-                Ok::<(), std::io::Error>(())
-            })
-            .await
+                    let (reader, writer) = &mut stream.split();
+                    reader.copy_into(writer).await?;
+                    Ok::<(), std::io::Error>(())
+                })
+                .await
+            }
         })
         .await?;
     Ok(())

examples/tcp-proxy.rs

@@ -14,24 +14,26 @@ async fn main() -> std::io::Result<()> {
     // accept connections and process them in parallel
     listener
         .incoming()
-        .try_for_each_concurrent(None, async move |client| {
-            runtime::spawn(async move {
-                let server = TcpStream::connect("127.0.0.1:8080").await?;
-                println!(
-                    "Proxying {} to {}",
-                    client.peer_addr()?,
-                    server.peer_addr()?
-                );
+        .try_for_each_concurrent(None, |client| {
+            async move {
+                runtime::spawn(async move {
+                    let server = TcpStream::connect("127.0.0.1:8080").await?;
+                    println!(
+                        "Proxying {} to {}",
+                        client.peer_addr()?,
+                        server.peer_addr()?
+                    );
 
-                let (cr, cw) = &mut client.split();
-                let (sr, sw) = &mut server.split();
-                let a = cr.copy_into(sw);
-                let b = sr.copy_into(cw);
-                try_join!(a, b)?;
+                    let (cr, cw) = &mut client.split();
+                    let (sr, sw) = &mut server.split();
+                    let a = cr.copy_into(sw);
+                    let b = sr.copy_into(cw);
+                    try_join!(a, b)?;
 
-                Ok::<(), std::io::Error>(())
-            })
-            .await
+                    Ok::<(), std::io::Error>(())
+                })
+                .await
+            }
         })
         .await?;
     Ok(())