cargo fmt

Signed-off-by: Yoshua Wuyts <yoshuawuyts@gmail.com>

Author: yoshuawuyts

benches/baseline.rs

@@ -59,9 +59,7 @@ mod baseline {
     fn spawn_many(b: &mut test::Bencher) {
         b.iter(|| {
             executor::block_on(async {
-                let tasks = (0..25_000)
-                    .map(|_| spawn(async {}))
-                    .collect::<Vec<_>>();
+                let tasks = (0..25_000).map(|_| spawn(async {})).collect::<Vec<_>>();
 
                 for task in tasks {
                     await!(task);
@@ -78,42 +76,41 @@ mod baseline {
         use tokio::reactor::Registration;
         b.iter(|| {
             executor::block_on(async {
-                 let tasks = (0..300)
-                     .map(|_| {
-                         spawn(async {
-                             let (r, s) = mio::Registration::new2();
-                             let registration = Registration::new();
-                             registration.register(&r).unwrap();
-
-                             let mut depth = 0;
-                             let mut capture = Some(r);
-
-                             spawn(
-                                 Compat01As03::new(future::poll_fn(move || loop {
-                                     if registration.poll_read_ready().unwrap().is_ready() {
-                                         depth += 1;
-                                         if depth == 300 {
-                                             capture.take().unwrap();
-                                             return Ok(Async::Ready(()));
-                                         }
-                                     } else {
-                                         s.set_readiness(mio::Ready::readable()).unwrap();
-                                         return Ok(Async::NotReady);
-                                     }
-                                 }))
-                                 .map(|_: Result<(), ()>| ()),
-                             )
-                         })
-                     })
-                     .collect::<Vec<_>>();
-
-                 for task in tasks {
-                     await!(task);
-                 }
+                let tasks = (0..300)
+                    .map(|_| {
+                        spawn(async {
+                            let (r, s) = mio::Registration::new2();
+                            let registration = Registration::new();
+                            registration.register(&r).unwrap();
+
+                            let mut depth = 0;
+                            let mut capture = Some(r);
+
+                            spawn(
+                                Compat01As03::new(future::poll_fn(move || loop {
+                                    if registration.poll_read_ready().unwrap().is_ready() {
+                                        depth += 1;
+                                        if depth == 300 {
+                                            capture.take().unwrap();
+                                            return Ok(Async::Ready(()));
+                                        }
+                                    } else {
+                                        s.set_readiness(mio::Ready::readable()).unwrap();
+                                        return Ok(Async::NotReady);
+                                    }
+                                }))
+                                .map(|_: Result<(), ()>| ()),
+                            )
+                        })
+                    })
+                    .collect::<Vec<_>>();
+
+                for task in tasks {
+                    await!(task);
+                }
             })
         });
-     }
-
+    }
 
     /// Spawn function for juliex to get back a handle
     pub fn spawn<F, T>(fut: F) -> JoinHandle<T>

runtime-raw/src/lib.rs

@@ -1,6 +1,6 @@
 //! Types for defining custom [Runtime](https://github.com/rustasync/runtime)s. See the
 //! [Runtime](https://docs.rs/runtime) documentation for more details.
-//! 
+//!
 //! These types are only necessary when implementing custom runtimes. If you're only trying to
 //! perform IO, then there's no need to bother with any of these types as they will have been
 //! implemented for you already.

runtime-raw/src/tcp.rs

@@ -40,7 +40,10 @@ pub trait TcpListener: Debug + Send {
     fn local_addr(&self) -> io::Result<SocketAddr>;
 
     /// Check if the listener is ready to accept connections.
-    fn poll_accept(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<Pin<Box<dyn TcpStream>>>>;
+    fn poll_accept(
+        self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<io::Result<Pin<Box<dyn TcpStream>>>>;
 
     /// Extracts the raw file descriptor.
     #[cfg(unix)]

src/net/tcp.rs

@@ -219,8 +219,9 @@ impl AsyncWrite for TcpStream {
 pub struct Connect {
     addrs: Option<io::Result<VecDeque<SocketAddr>>>,
     last_err: Option<io::Error>,
-    future:
-        Option<Pin<Box<dyn Future<Output = io::Result<Pin<Box<dyn runtime_raw::TcpStream>>>> + Send>>>,
+    future: Option<
+        Pin<Box<dyn Future<Output = io::Result<Pin<Box<dyn runtime_raw::TcpStream>>>> + Send>>,
+    >,
     runtime: &'static dyn runtime_raw::Runtime,
 }
 

src/task.rs

@@ -4,7 +4,7 @@ use std::pin::Pin;
 
 use futures::future::FutureObj;
 use futures::prelude::*;
-use futures::task::{Poll, Context};
+use futures::task::{Context, Poll};
 
 /// Spawn a future on the runtime's thread pool.
 ///