Rename Empty and associated funcs to Never

Never (the name for the nightly "!" type) more clearly expresses
the behavior of this Future. Rather than returning nothing,
Never (formerly Empty) never completes.

Author: cramertj

src/impls.rs

@@ -1,6 +1,6 @@
 use std::mem;
 
-use {Future, empty, Poll, Task};
+use {Future, never, Poll, Task};
 
 impl<T, E> Future for Box<Future<Item=T, Error=E>>
     where T: 'static,
@@ -22,7 +22,7 @@ impl<T, E> Future for Box<Future<Item=T, Error=E>>
         if let Some(f) = (**self).tailcall() {
             return Some(f)
         }
-        Some(mem::replace(self, Box::new(empty())))
+        Some(mem::replace(self, Box::new(never())))
     }
 }
 
@@ -46,7 +46,7 @@ impl<T, E> Future for Box<Future<Item=T, Error=E> + Send>
         if let Some(f) = (**self).tailcall() {
             return Some(f)
         }
-        let me = mem::replace(self, Box::new(empty()));
+        let me = mem::replace(self, Box::new(never()));
         let me: Box<Future<Item=T, Error=E>> = me;
         Some(me)
     }

src/lib.rs

@@ -171,15 +171,15 @@ pub mod executor;
 // Primitive futures
 mod collect;
 mod done;
-mod empty;
+mod never;
 mod failed;
 mod finished;
 mod lazy;
 mod oneshot;
 mod store;
 pub use collect::{collect, Collect};
 pub use done::{done, Done};
-pub use empty::{empty, Empty};
+pub use never::{never, Never};
 pub use failed::{failed, Failed};
 pub use finished::{finished, Finished};
 pub use lazy::{lazy, Lazy};

src/empty.rs renamed to src/never.rs

@@ -5,7 +5,7 @@ use {Future, Task, Poll};
 /// A future which is never resolved.
 ///
 /// This future can be created with the `empty` function.
-pub struct Empty<T, E>
+pub struct Never<T, E>
     where T: 'static,
           E: 'static,
 {
@@ -18,11 +18,11 @@ pub struct Empty<T, E>
 /// The returned future will never resolve with a success but is still
 /// susceptible to cancellation. That is, if a callback is scheduled on the
 /// returned future, it is only run once the future is dropped (canceled).
-pub fn empty<T: 'static, E: 'static>() -> Empty<T, E> {
-    Empty { _data: marker::PhantomData }
+pub fn never<T: 'static, E: 'static>() -> Never<T, E> {
+    Never { _data: marker::PhantomData }
 }
 
-impl<T, E> Future for Empty<T, E>
+impl<T, E> Future for Never<T, E>
     where T: 'static,
           E: 'static,
 {

src/select.rs

@@ -1,6 +1,6 @@
 use std::mem;
 
-use {Future, Task, empty, Poll};
+use {Future, Task, never, Poll};
 use util::Collapsed;
 
 /// Future for the `select` combinator, waiting for one of two futures to
@@ -113,7 +113,7 @@ impl<A, B> Future for SelectNext<A, B>
         match self.inner {
             OneOf::A(Collapsed::Tail(ref mut a)) |
             OneOf::B(Collapsed::Tail(ref mut a)) => {
-                Some(mem::replace(a, Box::new(empty())))
+                Some(mem::replace(a, Box::new(never())))
             }
             _ => None,
         }

src/select_all.rs

@@ -1,6 +1,6 @@
 use std::mem;
 
-use {Future, IntoFuture, Task, empty, Poll};
+use {Future, IntoFuture, Task, never, Poll};
 use util::Collapsed;
 
 /// Future for the `select_all` combinator, waiting for one of any of a list of
@@ -105,7 +105,7 @@ impl<A> Future for SelectAllNext<A>
         self.inner.collapse();
         match self.inner {
             Collapsed::Tail(ref mut a) => {
-                Some(mem::replace(a, Box::new(empty())))
+                Some(mem::replace(a, Box::new(never())))
             }
             _ => None,
         }

tests/all.rs

@@ -50,8 +50,8 @@ fn result_smoke() {
     assert_done(|| f_ok(1).select(f_err(2)).then(unselect), ok(1));
     assert_done(|| f_ok(1).select(Ok(2)).then(unselect), ok(1));
     assert_done(|| f_err(1).select(f_ok(1)).then(unselect), err(1));
-    assert_done(|| f_ok(1).select(empty()).then(unselect), Ok(1));
-    assert_done(|| empty().select(f_ok(1)).then(unselect), Ok(1));
+    assert_done(|| f_ok(1).select(never()).then(unselect), Ok(1));
+    assert_done(|| never().select(f_ok(1)).then(unselect), Ok(1));
     assert_done(|| f_ok(1).join(f_err(1)), Err(1));
     assert_done(|| f_ok(1).join(Ok(2)), Ok((1, 2)));
     assert_done(|| f_err(1).join(f_ok(1)), Err(1));
@@ -62,21 +62,21 @@ fn result_smoke() {
 }
 
 #[test]
-fn test_empty() {
-    fn empty() -> Empty<i32, u32> { futures::empty() }
-
-    assert_empty(|| empty());
-    assert_empty(|| empty().select(empty()));
-    assert_empty(|| empty().join(empty()));
-    assert_empty(|| empty().join(f_ok(1)));
-    assert_empty(|| f_ok(1).join(empty()));
-    assert_empty(|| empty().or_else(move |_| empty()));
-    assert_empty(|| empty().and_then(move |_| empty()));
-    assert_empty(|| f_err(1).or_else(move |_| empty()));
-    assert_empty(|| f_ok(1).and_then(move |_| empty()));
-    assert_empty(|| empty().map(|a| a + 1));
-    assert_empty(|| empty().map_err(|a| a + 1));
-    assert_empty(|| empty().then(|a| a));
+fn test_never() {
+    fn never() -> Never<i32, u32> { futures::never() }
+
+    assert_empty(|| never());
+    assert_empty(|| never().select(never()));
+    assert_empty(|| never().join(never()));
+    assert_empty(|| never().join(f_ok(1)));
+    assert_empty(|| f_ok(1).join(never()));
+    assert_empty(|| never().or_else(move |_| never()));
+    assert_empty(|| never().and_then(move |_| never()));
+    assert_empty(|| f_err(1).or_else(move |_| never()));
+    assert_empty(|| f_ok(1).and_then(move |_| never()));
+    assert_empty(|| never().map(|a| a + 1));
+    assert_empty(|| never().map_err(|a| a + 1));
+    assert_empty(|| never().then(|a| a));
 }
 
 #[test]
@@ -99,8 +99,8 @@ fn flatten() {
     assert_done(|| failed(1u32).map(finished).flatten(), err(1));
     assert_done(|| futures::finished::<_, u8>(futures::finished::<_, u32>(1))
                            .flatten(), ok(1));
-    assert_empty(|| finished(empty::<i32, u32>()).flatten());
-    assert_empty(|| empty::<i32, u32>().map(finished).flatten());
+    assert_empty(|| finished(never::<i32, u32>()).flatten());
+    assert_empty(|| never::<i32, u32>().map(finished).flatten());
 }
 
 #[test]
@@ -256,10 +256,10 @@ fn select2() {
         }
     }
 
-    assert_done(|| f_ok(2).select(empty()).then(d), Ok(2));
-    assert_done(|| empty().select(f_ok(2)).then(d), Ok(2));
-    assert_done(|| f_err(2).select(empty()).then(d), Err(2));
-    assert_done(|| empty().select(f_err(2)).then(d), Err(2));
+    assert_done(|| f_ok(2).select(never()).then(d), Ok(2));
+    assert_done(|| never().select(f_ok(2)).then(d), Ok(2));
+    assert_done(|| f_err(2).select(never()).then(d), Err(2));
+    assert_done(|| never().select(f_err(2)).then(d), Err(2));
 
     assert_done(|| {
         f_ok(1).select(f_ok(2))
@@ -342,7 +342,7 @@ fn select2() {
     // Cancel on early drop
     {
         let (tx, rx) = channel();
-        let f = f_ok(1).select(empty().map(move |()| {
+        let f = f_ok(1).select(never().map(move |()| {
             tx.send(()).unwrap();
             1
         }));