run cargo fmt

Author: expenses

src/delay.rs

@@ -44,11 +44,7 @@ impl Delay {
     pub(crate) fn new_handle(at: Instant, handle: TimerHandle) -> Delay {
         let inner = match handle.inner.upgrade() {
             Some(i) => i,
-            None => {
-                return Delay {
-                    state: None,
-                }
-            }
+            None => return Delay { state: None },
         };
         let state = Arc::new(Node::new(ScheduledTimer {
             at: Mutex::new(Some(at)),
@@ -62,15 +58,11 @@ impl Delay {
         // timer, meaning that we'll want to immediately return an error from
         // `poll`.
         if inner.list.push(&state).is_err() {
-            return Delay {
-                state: None,
-            };
+            return Delay { state: None };
         }
 
         inner.waker.wake();
-        Delay {
-            state: Some(state),
-        }
+        Delay { state: Some(state) }
     }
 
     /// Resets this timeout to an new timeout which will fire at the time

src/delay_wasm.rs

@@ -2,32 +2,35 @@
 
 use gloo_timers::future::TimeoutFuture;
 use send_wrapper::SendWrapper;
-use std::{time::Duration, pin::Pin, task::{Context, Poll}, future::Future};
+use std::{
+    future::Future,
+    pin::Pin,
+    task::{Context, Poll},
+    time::Duration,
+};
 
 /// A version of `Delay` that works on wasm.
 #[derive(Debug)]
 pub struct Delay(SendWrapper<TimeoutFuture>);
 
 impl Delay {
-	/// Creates a new future which will fire at `dur` time into the future.
-	#[inline]
-	pub fn new(dur: Duration) -> Delay {
-		Self(
-			SendWrapper::new(TimeoutFuture::new(dur.as_millis() as u32))
-		)
-	}
+    /// Creates a new future which will fire at `dur` time into the future.
+    #[inline]
+    pub fn new(dur: Duration) -> Delay {
+        Self(SendWrapper::new(TimeoutFuture::new(dur.as_millis() as u32)))
+    }
 
-	/// Resets the timeout. Panics on wasm.
-	#[inline]
-	pub fn reset(&mut self, at: Duration) {
-		*self = Delay::new(at);
-	}
+    /// Resets the timeout. Panics on wasm.
+    #[inline]
+    pub fn reset(&mut self, at: Duration) {
+        *self = Delay::new(at);
+    }
 }
 
 impl Future for Delay {
-	type Output = ();
+    type Output = ();
 
-	fn poll(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output> {
-		Pin::new(&mut *Pin::into_inner(self).0).poll(cx)
-	}
+    fn poll(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output> {
+        Pin::new(&mut *Pin::into_inner(self).0).poll(cx)
+    }
 }