From 1143af067148d5d62d813ea0b790b1aa1f8bcce2 Mon Sep 17 00:00:00 2001 From: Alex Crichton Date: Fri, 18 Nov 2016 14:53:24 -0800 Subject: [PATCH] Rename finished => ok, failed => err Also rename done => result, and add a bunch of reexports for all the old names. For now the `Result` type is exported as `FutureResult` to prevent conflict with the `Result` type (very likely to happen), but we should change that as part of 0.2. Closes #230 --- src/future/{failed.rs => err.rs} | 16 +++--- src/future/join_all.rs | 12 ++-- src/future/lazy.rs | 4 +- src/future/mod.rs | 94 ++++++++++++++++++------------- src/future/{finished.rs => ok.rs} | 14 ++--- src/future/{done.rs => result.rs} | 21 ++++--- src/stream/mod.rs | 4 +- src/stream/unfold.rs | 2 +- tests/all.rs | 82 +++++++++++++-------------- tests/channel.rs | 4 +- tests/eager_drop.rs | 6 +- tests/eventual.rs | 18 +++--- tests/fuse.rs | 4 +- tests/future_flatten_stream.rs | 6 +- tests/oneshot.rs | 4 +- tests/recurse.rs | 6 +- tests/select_all.rs | 6 +- tests/select_ok.rs | 18 +++--- tests/sink.rs | 6 +- tests/stream.rs | 10 ++-- tests/support/mod.rs | 10 ++-- 21 files changed, 184 insertions(+), 163 deletions(-) rename src/future/{failed.rs => err.rs} (60%) rename src/future/{finished.rs => ok.rs} (63%) rename src/future/{done.rs => result.rs} (54%) diff --git a/src/future/failed.rs b/src/future/err.rs similarity index 60% rename from src/future/failed.rs rename to src/future/err.rs index 038469ab3d8..35155fd94b7 100644 --- a/src/future/failed.rs +++ b/src/future/err.rs @@ -1,4 +1,4 @@ -//! Definition of the Failed combinator, an error value that's immediately +//! Definition of the Err combinator, an error value that's immediately //! ready. use core::marker; @@ -7,9 +7,9 @@ use {Future, Poll}; /// A future representing a finished but erroneous computation. /// -/// Created by the `failed` function. +/// Created by the `err` function. #[must_use = "futures do nothing unless polled"] -pub struct Failed { +pub struct Err { _t: marker::PhantomData, e: Option, } @@ -24,17 +24,17 @@ pub struct Failed { /// ``` /// use futures::future::*; /// -/// let future_of_err_1 = failed::(1); +/// let future_of_err_1 = err::(1); /// ``` -pub fn failed(e: E) -> Failed { - Failed { _t: marker::PhantomData, e: Some(e) } +pub fn err(e: E) -> Err { + Err { _t: marker::PhantomData, e: Some(e) } } -impl Future for Failed { +impl Future for Err { type Item = T; type Error = E; fn poll(&mut self) -> Poll { - Err(self.e.take().expect("cannot poll Failed twice")) + Err(self.e.take().expect("cannot poll Err twice")) } } diff --git a/src/future/join_all.rs b/src/future/join_all.rs index 97396e042d4..f20a556e352 100644 --- a/src/future/join_all.rs +++ b/src/future/join_all.rs @@ -39,18 +39,18 @@ pub struct JoinAll /// use futures::future::*; /// /// let f = join_all(vec![ -/// finished::(1), -/// finished::(2), -/// finished::(3), +/// ok::(1), +/// ok::(2), +/// ok::(3), /// ]); /// let f = f.map(|x| { /// assert_eq!(x, [1, 2, 3]); /// }); /// /// let f = join_all(vec![ -/// finished::(1).boxed(), -/// failed::(2).boxed(), -/// finished::(3).boxed(), +/// ok::(1).boxed(), +/// err::(2).boxed(), +/// ok::(3).boxed(), /// ]); /// let f = f.then(|x| { /// assert_eq!(x, Err(2)); diff --git a/src/future/lazy.rs b/src/future/lazy.rs index e7b70b77d21..9640ab93ebc 100644 --- a/src/future/lazy.rs +++ b/src/future/lazy.rs @@ -32,9 +32,9 @@ enum _Lazy { /// ``` /// use futures::future::*; /// -/// let a = lazy(|| finished::(1)); +/// let a = lazy(|| ok::(1)); /// -/// let b = lazy(|| -> Done { +/// let b = lazy(|| -> Ok { /// panic!("oh no!") /// }); /// drop(b); // closure is never run diff --git a/src/future/mod.rs b/src/future/mod.rs index c474fa0e5ac..0aafd07bac3 100644 --- a/src/future/mod.rs +++ b/src/future/mod.rs @@ -3,17 +3,35 @@ //! This module contains the `Future` trait and a number of adaptors for this //! trait. See the crate docs, and the docs for `Future`, for full detail. +use core::result; + // Primitive futures -mod done; mod empty; -mod failed; -mod finished; +#[path = "err.rs"] // remove when deprecated reexports are gone +mod err_; mod lazy; -pub use self::done::{done, Done}; +#[path = "ok.rs"] +mod ok_; +#[path = "result.rs"] +mod result_; pub use self::empty::{empty, Empty}; -pub use self::failed::{failed, Failed}; -pub use self::finished::{finished, Finished}; +pub use self::err_::{err, Err}; pub use self::lazy::{lazy, Lazy}; +pub use self::ok_::{ok, Ok}; +pub use self::result_::{result, FutureResult}; + +#[doc(hidden)] +#[deprecated(since = "0.1.4", note = "use `ok` instead")] +#[cfg(feature = "with-deprecated")] +pub use self::{ok as finished, Ok as Finished}; +#[doc(hidden)] +#[deprecated(since = "0.1.4", note = "use `err` instead")] +#[cfg(feature = "with-deprecated")] +pub use self::{err as failed, Err as Failed}; +#[doc(hidden)] +#[deprecated(since = "0.1.4", note = "use `result` instead")] +#[cfg(feature = "with-deprecated")] +pub use self::{result as done, FutureResult as Done}; // combinators mod and_then; @@ -220,7 +238,7 @@ pub trait Future { /// This function does not attempt to catch panics. If the `poll` function /// panics, panics will be propagated to the caller. #[cfg(feature = "use_std")] - fn wait(self) -> Result + fn wait(self) -> result::Result where Self: Sized { ::executor::spawn(self).wait_future() @@ -239,14 +257,14 @@ pub trait Future { /// ``` /// use futures::future::*; /// - /// let a: BoxFuture = done(Ok(1)).boxed(); + /// let a: BoxFuture = result(Ok(1)).boxed(); /// ``` #[cfg(feature = "use_std")] - fn boxed(self) -> BoxFuture + fn boxed(self) -> BoxFuture where Self: Sized + Send + 'static { - ::std::boxed::Box::new(self) - } + ::std::boxed::Box::new(self) + } /// Map this future's result to a different type, returning a new future of /// the resulting type. @@ -268,7 +286,7 @@ pub trait Future { /// ``` /// use futures::future::*; /// - /// let future_of_1 = finished::(1); + /// let future_of_1 = ok::(1); /// let future_of_4 = future_of_1.map(|x| x + 3); /// ``` fn map(self, f: F) -> Map @@ -297,7 +315,7 @@ pub trait Future { /// ``` /// use futures::future::*; /// - /// let future_of_err_1 = failed::(1); + /// let future_of_err_1 = err::(1); /// let future_of_err_4 = future_of_err_1.map_err(|x| x + 3); /// ``` fn map_err(self, f: F) -> MapErr @@ -331,21 +349,21 @@ pub trait Future { /// ``` /// use futures::future::*; /// - /// let future_of_1 = finished::(1); + /// let future_of_1 = ok::(1); /// let future_of_4 = future_of_1.then(|x| { /// x.map(|y| y + 3) /// }); /// - /// let future_of_err_1 = failed::(1); + /// let future_of_err_1 = err::(1); /// let future_of_4 = future_of_err_1.then(|x| { /// match x { /// Ok(_) => panic!("expected an error"), - /// Err(y) => finished::(y + 3), + /// Err(y) => ok::(y + 3), /// } /// }); /// ``` fn then(self, f: F) -> Then - where F: FnOnce(Result) -> B, + where F: FnOnce(result::Result) -> B, B: IntoFuture, Self: Sized, { @@ -374,13 +392,13 @@ pub trait Future { /// ``` /// use futures::future::*; /// - /// let future_of_1 = finished::(1); + /// let future_of_1 = ok::(1); /// let future_of_4 = future_of_1.and_then(|x| { /// Ok(x + 3) /// }); /// - /// let future_of_err_1 = failed::(1); - /// future_of_err_1.and_then(|_| -> Done { + /// let future_of_err_1 = err::(1); + /// future_of_err_1.and_then(|_| -> Ok { /// panic!("should not be called in case of an error"); /// }); /// ``` @@ -414,13 +432,13 @@ pub trait Future { /// ``` /// use futures::future::*; /// - /// let future_of_err_1 = failed::(1); + /// let future_of_err_1 = err::(1); /// let future_of_4 = future_of_err_1.or_else(|x| -> Result { /// Ok(x + 3) /// }); /// - /// let future_of_1 = finished::(1); - /// future_of_1.or_else(|_| -> Done { + /// let future_of_1 = ok::(1); + /// future_of_1.or_else(|_| -> Ok { /// panic!("should not be called in case of success"); /// }); /// ``` @@ -455,7 +473,7 @@ pub trait Future { /// a.select(b).then(|res| { /// match res { /// Ok((a, b)) => b.map(move |b| (a, b)).boxed(), - /// Err((a, _)) => failed(a).boxed(), + /// Err((a, _)) => err(a).boxed(), /// } /// }).boxed() /// } @@ -490,8 +508,8 @@ pub trait Future { /// ``` /// use futures::future::*; /// - /// let a = finished::(1); - /// let b = finished::(2); + /// let a = ok::(1); + /// let b = ok::(2); /// let pair = a.join(b); /// /// pair.map(|(a, b)| { @@ -552,12 +570,12 @@ pub trait Future { /// use futures::stream::Stream; /// use futures::future::*; /// - /// let future = finished::<_, bool>(17); + /// let future = ok::<_, bool>(17); /// let mut stream = future.into_stream(); /// assert_eq!(Ok(Async::Ready(Some(17))), stream.poll()); /// assert_eq!(Ok(Async::Ready(None)), stream.poll()); /// - /// let future = failed::(19); + /// let future = err::(19); /// let mut stream = future.into_stream(); /// assert_eq!(Err(19), stream.poll()); /// assert_eq!(Ok(Async::Ready(None)), stream.poll()); @@ -587,7 +605,7 @@ pub trait Future { /// ``` /// use futures::future::*; /// - /// let future_of_a_future = finished::<_, u32>(finished::(1)); + /// let future_of_a_future = ok::<_, u32>(ok::(1)); /// let future_of_1 = future_of_a_future.flatten(); /// ``` fn flatten(self) -> Flatten @@ -619,7 +637,7 @@ pub trait Future { /// use futures::future::*; /// /// let stream_items = vec![Ok(17), Err(true), Ok(19)]; - /// let future_of_a_stream = finished::<_, bool>(stream::iter(stream_items)); + /// let future_of_a_stream = ok::<_, bool>(stream::iter(stream_items)); /// /// let stream = future_of_a_stream.flatten_stream(); /// @@ -659,14 +677,14 @@ pub trait Future { /// use futures::Async; /// use futures::future::*; /// - /// let mut future = finished::(2); + /// let mut future = ok::(2); /// assert_eq!(future.poll(), Ok(Async::Ready(2))); /// /// // Normally, a call such as this would panic: /// //future.poll(); /// /// // This, however, is guaranteed to not panic - /// let mut future = finished::(2).fuse(); + /// let mut future = ok::(2).fuse(); /// assert_eq!(future.poll(), Ok(Async::Ready(2))); /// assert_eq!(future.poll(), Ok(Async::NotReady)); /// ``` @@ -694,12 +712,12 @@ pub trait Future { /// ```rust /// use futures::future::*; /// - /// let mut future = finished::(2); + /// let mut future = ok::(2); /// assert!(future.catch_unwind().wait().is_ok()); /// /// let mut future = lazy(|| { /// panic!(); - /// finished::(2) + /// ok::(2) /// }); /// assert!(future.catch_unwind().wait().is_err()); /// ``` @@ -755,12 +773,12 @@ impl IntoFuture for F { } } -impl IntoFuture for Result { - type Future = Done; +impl IntoFuture for result::Result { + type Future = FutureResult; type Item = T; type Error = E; - fn into_future(self) -> Done { - done(self) + fn into_future(self) -> FutureResult { + result(self) } } diff --git a/src/future/finished.rs b/src/future/ok.rs similarity index 63% rename from src/future/finished.rs rename to src/future/ok.rs index ead214d35fa..2a34af2241e 100644 --- a/src/future/finished.rs +++ b/src/future/ok.rs @@ -1,4 +1,4 @@ -//! Definition of the Finished combinator, a successful value that's immediately +//! Definition of the Ok combinator, a successful value that's immediately //! ready. use core::marker; @@ -9,7 +9,7 @@ use {Future, Poll, Async}; /// /// Created by the `finished` function. #[must_use = "futures do nothing unless polled"] -pub struct Finished { +pub struct Ok { t: Option, _e: marker::PhantomData, } @@ -25,18 +25,18 @@ pub struct Finished { /// ``` /// use futures::future::*; /// -/// let future_of_1 = finished::(1); +/// let future_of_1 = ok::(1); /// ``` -pub fn finished(t: T) -> Finished { - Finished { t: Some(t), _e: marker::PhantomData } +pub fn ok(t: T) -> Ok { + Ok { t: Some(t), _e: marker::PhantomData } } -impl Future for Finished { +impl Future for Ok { type Item = T; type Error = E; fn poll(&mut self) -> Poll { - Ok(Async::Ready(self.t.take().expect("cannot poll Finished twice"))) + Ok(Async::Ready(self.t.take().expect("cannot poll Ok twice"))) } } diff --git a/src/future/done.rs b/src/future/result.rs similarity index 54% rename from src/future/done.rs rename to src/future/result.rs index 4b63752d885..d51c7617c7c 100644 --- a/src/future/done.rs +++ b/src/future/result.rs @@ -1,4 +1,6 @@ -//! Definition of the `Done` (immediately finished) combinator +//! Definition of the `Result` (immediately finished) combinator + +use core::result; use {Future, Poll, Async}; @@ -6,8 +8,9 @@ use {Future, Poll, Async}; /// /// Created by the `done` function. #[must_use = "futures do nothing unless polled"] -pub struct Done { - inner: Option>, +// TODO: rename this to `Result` on the next major version +pub struct FutureResult { + inner: Option>, } /// Creates a new "leaf future" which will resolve with the given result. @@ -21,18 +24,18 @@ pub struct Done { /// ``` /// use futures::future::*; /// -/// let future_of_1 = done::(Ok(1)); -/// let future_of_err_2 = done::(Err(2)); +/// let future_of_1 = result::(Ok(1)); +/// let future_of_err_2 = result::(Err(2)); /// ``` -pub fn done(r: Result) -> Done { - Done { inner: Some(r) } +pub fn result(r: result::Result) -> FutureResult { + FutureResult { inner: Some(r) } } -impl Future for Done { +impl Future for FutureResult { type Item = T; type Error = E; fn poll(&mut self) -> Poll { - self.inner.take().expect("cannot poll Done twice").map(Async::Ready) + self.inner.take().expect("cannot poll Result twice").map(Async::Ready) } } diff --git a/src/stream/mod.rs b/src/stream/mod.rs index bd0869d52dd..2ea6ef614ec 100755 --- a/src/stream/mod.rs +++ b/src/stream/mod.rs @@ -504,10 +504,10 @@ pub trait Stream { /// /// ``` /// use futures::stream::{self, Stream}; - /// use futures::future::{finished, Future}; + /// use futures::future::{ok, Future}; /// /// let number_stream = stream::iter::<_, _, ()>((0..6).map(Ok)); - /// let sum = number_stream.fold(0, |a, b| finished(a + b)); + /// let sum = number_stream.fold(0, |a, b| ok(a + b)); /// assert_eq!(sum.wait(), Ok(15)); /// ``` fn fold(self, init: T, f: F) -> Fold diff --git a/src/stream/unfold.rs b/src/stream/unfold.rs index bb35bed9c1b..ebad321db00 100644 --- a/src/stream/unfold.rs +++ b/src/stream/unfold.rs @@ -36,7 +36,7 @@ use stream::Stream; /// if state <= 2 { /// let next_state = state + 1; /// let yielded = state * 2; -/// let fut = future::finished::<_, u32>((yielded, next_state)); +/// let fut = future::ok::<_, u32>((yielded, next_state)); /// Some(fut) /// } else { /// None diff --git a/tests/all.rs b/tests/all.rs index 99233cd9a0e..6f19112f736 100644 --- a/tests/all.rs +++ b/tests/all.rs @@ -32,36 +32,36 @@ fn result_smoke() { is_future_v::<(i32, i32), u32, _>(f_ok(1).join(Err(3))); is_future_v::(f_ok(1).map(move |a| f_ok(a)).flatten()); - assert_done(|| f_ok(1), ok(1)); - assert_done(|| f_err(1), err(1)); - assert_done(|| done(Ok(1)), ok(1)); - assert_done(|| done(Err(1)), err(1)); - assert_done(|| finished(1), ok(1)); - assert_done(|| failed(1), err(1)); - assert_done(|| f_ok(1).map(|a| a + 2), ok(3)); - assert_done(|| f_err(1).map(|a| a + 2), err(1)); - assert_done(|| f_ok(1).map_err(|a| a + 2), ok(1)); - assert_done(|| f_err(1).map_err(|a| a + 2), err(3)); - assert_done(|| f_ok(1).and_then(|a| Ok(a + 2)), ok(3)); - assert_done(|| f_err(1).and_then(|a| Ok(a + 2)), err(1)); - assert_done(|| f_ok(1).and_then(|a| Err(a as u32 + 3)), err(4)); - assert_done(|| f_err(1).and_then(|a| Err(a as u32 + 4)), err(1)); - assert_done(|| f_ok(1).or_else(|a| Ok(a as i32 + 2)), ok(1)); - assert_done(|| f_err(1).or_else(|a| Ok(a as i32 + 2)), ok(3)); - assert_done(|| f_ok(1).or_else(|a| Err(a + 3)), ok(1)); - assert_done(|| f_err(1).or_else(|a| Err(a + 4)), err(5)); - 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), r_ok(1)); + assert_done(|| f_err(1), r_err(1)); + assert_done(|| result(Ok(1)), r_ok(1)); + assert_done(|| result(Err(1)), r_err(1)); + assert_done(|| ok(1), r_ok(1)); + assert_done(|| err(1), r_err(1)); + assert_done(|| f_ok(1).map(|a| a + 2), r_ok(3)); + assert_done(|| f_err(1).map(|a| a + 2), r_err(1)); + assert_done(|| f_ok(1).map_err(|a| a + 2), r_ok(1)); + assert_done(|| f_err(1).map_err(|a| a + 2), r_err(3)); + assert_done(|| f_ok(1).and_then(|a| Ok(a + 2)), r_ok(3)); + assert_done(|| f_err(1).and_then(|a| Ok(a + 2)), r_err(1)); + assert_done(|| f_ok(1).and_then(|a| Err(a as u32 + 3)), r_err(4)); + assert_done(|| f_err(1).and_then(|a| Err(a as u32 + 4)), r_err(1)); + assert_done(|| f_ok(1).or_else(|a| Ok(a as i32 + 2)), r_ok(1)); + assert_done(|| f_err(1).or_else(|a| Ok(a as i32 + 2)), r_ok(3)); + assert_done(|| f_ok(1).or_else(|a| Err(a + 3)), r_ok(1)); + assert_done(|| f_err(1).or_else(|a| Err(a + 4)), r_err(5)); + assert_done(|| f_ok(1).select(f_err(2)).then(unselect), r_ok(1)); + assert_done(|| f_ok(1).select(Ok(2)).then(unselect), r_ok(1)); + assert_done(|| f_err(1).select(f_ok(1)).then(unselect), r_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).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)); - assert_done(|| f_ok(1).then(|_| Ok(2)), ok(2)); - assert_done(|| f_ok(1).then(|_| Err(2)), err(2)); - assert_done(|| f_err(1).then(|_| Ok(2)), ok(2)); - assert_done(|| f_err(1).then(|_| Err(2)), err(2)); + assert_done(|| f_ok(1).then(|_| Ok(2)), r_ok(2)); + assert_done(|| f_ok(1).then(|_| Err(2)), r_err(2)); + assert_done(|| f_err(1).then(|_| Ok(2)), r_ok(2)); + assert_done(|| f_err(1).then(|_| Err(2)), r_err(2)); } #[test] @@ -83,27 +83,27 @@ fn test_empty() { } #[test] -fn test_finished() { - assert_done(|| finished(1), ok(1)); - assert_done(|| failed(1), err(1)); +fn test_ok() { + assert_done(|| ok(1), r_ok(1)); + assert_done(|| err(1), r_err(1)); } #[test] fn flatten() { - fn finished(a: T) -> Finished { - future::finished(a) + fn ok(a: T) -> Ok { + future::ok(a) } - fn failed(b: E) -> Failed { - future::failed(b) + fn err(b: E) -> Err { + future::err(b) } - assert_done(|| finished(finished(1)).flatten(), ok(1)); - assert_done(|| finished(failed(1)).flatten(), err(1)); - assert_done(|| failed(1u32).map(finished).flatten(), err(1)); - assert_done(|| future::finished::<_, u8>(future::finished::<_, u32>(1)) - .flatten(), ok(1)); - assert_empty(|| finished(empty::()).flatten()); - assert_empty(|| empty::().map(finished).flatten()); + assert_done(|| ok(ok(1)).flatten(), r_ok(1)); + assert_done(|| ok(err(1)).flatten(), r_err(1)); + assert_done(|| err(1u32).map(ok).flatten(), r_err(1)); + assert_done(|| future::ok::<_, u8>(future::ok::<_, u32>(1)) + .flatten(), r_ok(1)); + assert_empty(|| ok(empty::()).flatten()); + assert_empty(|| empty::().map(ok).flatten()); } #[test] @@ -207,7 +207,7 @@ fn join_cancels() { fn join_incomplete() { let (a, b) = oneshot::channel::(); let (tx, rx) = channel(); - let mut f = executor::spawn(finished(1).join(b).map(move |r| tx.send(r).unwrap())); + let mut f = executor::spawn(ok(1).join(b).map(move |r| tx.send(r).unwrap())); assert!(f.poll_future(unpark_noop()).ok().unwrap().is_not_ready()); assert!(rx.try_recv().is_err()); a.complete(2); @@ -225,7 +225,7 @@ fn join_incomplete() { let (a, b) = oneshot::channel::(); let (tx, rx) = channel(); - let mut f = executor::spawn(finished(1).join(b).map_err(move |_r| tx.send(2).unwrap())); + let mut f = executor::spawn(ok(1).join(b).map_err(move |_r| tx.send(2).unwrap())); assert!(f.poll_future(unpark_noop()).ok().unwrap().is_not_ready()); assert!(rx.try_recv().is_err()); drop(a); diff --git a/tests/channel.rs b/tests/channel.rs index c844b0287cc..b0c270dadc3 100644 --- a/tests/channel.rs +++ b/tests/channel.rs @@ -4,7 +4,7 @@ use std::sync::Arc; use std::sync::atomic::*; use futures::{Future, Async, Stream, Sink}; -use futures::future::done; +use futures::future::result; use futures::executor; use futures::sync::mpsc; @@ -29,7 +29,7 @@ fn sequence() { fn send(n: u32, sender: mpsc::Sender) -> Box + Send> { if n == 0 { - return done(Ok(())).boxed() + return result(Ok(())).boxed() } sender.send(n).map_err(|_| ()).and_then(move |sender| { send(n - 1, sender) diff --git a/tests/eager_drop.rs b/tests/eager_drop.rs index d1118489547..507a9fdd670 100644 --- a/tests/eager_drop.rs +++ b/tests/eager_drop.rs @@ -15,7 +15,7 @@ fn map() { // point. let (tx, rx) = channel::<()>(); let (tx2, rx2) = channel(); - failed::(1).map(move |a| { drop(tx); a }).map_err(move |_| { + err::(1).map(move |a| { drop(tx); a }).map_err(move |_| { assert!(rx.recv().is_err()); tx2.send(()).unwrap() }).forget(); @@ -28,7 +28,7 @@ fn map_err() { // point. let (tx, rx) = channel::<()>(); let (tx2, rx2) = channel(); - finished::(1).map_err(move |a| { drop(tx); a }).map(move |_| { + ok::(1).map_err(move |a| { drop(tx); a }).map(move |_| { assert!(rx.recv().is_err()); tx2.send(()).unwrap() }).forget(); @@ -57,7 +57,7 @@ fn and_then_drops_eagerly() { FutureData { _data: tx, future: p }.and_then(move |_| { assert!(rx.recv().is_err()); tx2.send(()).unwrap(); - finished(1) + ok(1) }).forget(); assert!(rx2.try_recv().is_err()); c.complete(()); diff --git a/tests/eventual.rs b/tests/eventual.rs index 71223445b05..feb4606ba4f 100644 --- a/tests/eventual.rs +++ b/tests/eventual.rs @@ -7,7 +7,7 @@ use std::sync::mpsc; use std::thread; use futures::Future; -use futures::future::{finished, failed}; +use futures::future::{ok, err}; use futures::sync::oneshot; #[test] @@ -15,9 +15,9 @@ fn and_then1() { let (tx, rx) = mpsc::channel(); let tx2 = tx.clone(); - let p1 = finished::<_, i32>("a").then(move |t| { tx2.send("first").unwrap(); t }); + let p1 = ok::<_, i32>("a").then(move |t| { tx2.send("first").unwrap(); t }); let tx2 = tx.clone(); - let p2 = finished("b").then(move |t| { tx2.send("second").unwrap(); t }); + let p2 = ok("b").then(move |t| { tx2.send("second").unwrap(); t }); let f = p1.and_then(|_| p2); assert!(rx.try_recv().is_err()); @@ -33,9 +33,9 @@ fn and_then2() { let (tx, rx) = mpsc::channel(); let tx2 = tx.clone(); - let p1 = failed::(2).then(move |t| { tx2.send("first").unwrap(); t }); + let p1 = err::(2).then(move |t| { tx2.send("first").unwrap(); t }); let tx2 = tx.clone(); - let p2 = finished("b").then(move |t| { tx2.send("second").unwrap(); t }); + let p2 = ok("b").then(move |t| { tx2.send("second").unwrap(); t }); let f = p1.and_then(|_| p2); assert!(rx.try_recv().is_err()); @@ -114,13 +114,13 @@ fn cancel1() { #[test] fn map_err1() { - finished::(1).map_err(|_| panic!()).forget(); + ok::(1).map_err(|_| panic!()).forget(); } #[test] fn map_err2() { let (tx, rx) = mpsc::channel(); - failed::(1).map_err(move |v| tx.send(v).unwrap()).forget(); + err::(1).map_err(move |v| tx.send(v).unwrap()).forget(); assert_eq!(rx.recv(), Ok(1)); assert!(rx.recv().is_err()); } @@ -162,7 +162,7 @@ fn or_else2() { p1.or_else(move |_| { tx.send(()).unwrap(); - finished::(1) + ok::(1) }).forget(); c1.complete(2); @@ -172,7 +172,7 @@ fn or_else2() { #[test] fn join1() { let (tx, rx) = mpsc::channel(); - finished::(1).join(finished(2)) + ok::(1).join(ok(2)) .map(move |v| tx.send(v).unwrap()) .forget(); assert_eq!(rx.recv(), Ok((1, 2))); diff --git a/tests/fuse.rs b/tests/fuse.rs index 4a2d9da5335..cffb8be92d9 100644 --- a/tests/fuse.rs +++ b/tests/fuse.rs @@ -1,6 +1,6 @@ extern crate futures; -use futures::future::{finished, Future}; +use futures::future::{ok, Future}; use futures::executor; mod support; @@ -8,7 +8,7 @@ use support::*; #[test] fn fuse() { - let mut future = executor::spawn(finished::(2).fuse()); + let mut future = executor::spawn(ok::(2).fuse()); assert!(future.poll_future(unpark_panic()).unwrap().is_ready()); assert!(future.poll_future(unpark_panic()).unwrap().is_not_ready()); } diff --git a/tests/future_flatten_stream.rs b/tests/future_flatten_stream.rs index 10715b0df80..56ca6894452 100644 --- a/tests/future_flatten_stream.rs +++ b/tests/future_flatten_stream.rs @@ -4,13 +4,13 @@ extern crate futures; use core::marker; use futures::{Stream, Future, Poll}; -use futures::future::{finished, failed}; +use futures::future::{ok, err}; use futures::stream; #[test] fn successful_future() { let stream_items = vec![Ok(17), Err(true), Ok(19)]; - let future_of_a_stream = finished::<_, bool>(stream::iter(stream_items)); + let future_of_a_stream = ok::<_, bool>(stream::iter(stream_items)); let stream = future_of_a_stream.flatten_stream(); @@ -36,7 +36,7 @@ impl Stream for PanickingStream { #[test] fn failed_future() { - let future_of_a_stream = failed::, _>(10); + let future_of_a_stream = err::, _>(10); let stream = future_of_a_stream.flatten_stream(); let mut iter = stream.wait(); assert_eq!(Err(10), iter.next().unwrap()); diff --git a/tests/oneshot.rs b/tests/oneshot.rs index 165ae20018c..ef01ac10437 100644 --- a/tests/oneshot.rs +++ b/tests/oneshot.rs @@ -4,7 +4,7 @@ use std::sync::mpsc; use std::thread; use futures::{Future, Poll}; -use futures::future::{lazy, finished}; +use futures::future::{lazy, ok}; use futures::sync::oneshot::*; mod support; @@ -19,7 +19,7 @@ fn smoke_poll() { drop(rx); assert!(tx.poll_cancel().unwrap().is_ready()); assert!(tx.poll_cancel().unwrap().is_ready()); - finished::<(), ()>(()) + ok::<(), ()>(()) })); assert!(task.poll_future(unpark_noop()).unwrap().is_ready()); } diff --git a/tests/recurse.rs b/tests/recurse.rs index 15c91f5474d..465bafaacf8 100644 --- a/tests/recurse.rs +++ b/tests/recurse.rs @@ -2,15 +2,15 @@ extern crate futures; use std::sync::mpsc::channel; -use futures::future::{finished, Future}; +use futures::future::{ok, Future}; #[test] fn lots() { fn doit(n: usize) -> Box + Send> { if n == 0 { - finished(()).boxed() + ok(()).boxed() } else { - finished(n - 1).and_then(doit).boxed() + ok(n - 1).and_then(doit).boxed() } } diff --git a/tests/select_all.rs b/tests/select_all.rs index 08dd6fe6a76..8f61ee4f3d8 100644 --- a/tests/select_all.rs +++ b/tests/select_all.rs @@ -5,9 +5,9 @@ use futures::future::*; #[test] fn smoke() { let v = vec![ - finished(1).boxed(), - failed(2).boxed(), - finished(3).boxed(), + ok(1).boxed(), + err(2).boxed(), + ok(3).boxed(), ]; let (i, idx, v) = select_all(v).wait().ok().unwrap(); diff --git a/tests/select_ok.rs b/tests/select_ok.rs index 387196d35cc..017050bb587 100644 --- a/tests/select_ok.rs +++ b/tests/select_ok.rs @@ -3,12 +3,12 @@ extern crate futures; use futures::future::*; #[test] -fn ignore_failed() { +fn ignore_err() { let v = vec![ - failed(1).boxed(), - failed(2).boxed(), - finished(3).boxed(), - finished(4).boxed(), + err(1).boxed(), + err(2).boxed(), + ok(3).boxed(), + ok(4).boxed(), ]; let (i, v) = select_ok(v).wait().ok().unwrap(); @@ -23,11 +23,11 @@ fn ignore_failed() { } #[test] -fn last_failed() { +fn last_err() { let v = vec![ - finished(1).boxed(), - failed(2).boxed(), - failed(3).boxed(), + ok(1).boxed(), + err(2).boxed(), + err(3).boxed(), ]; let (i, v) = select_ok(v).wait().ok().unwrap(); diff --git a/tests/sink.rs b/tests/sink.rs index 5df171bbba0..3d14519c4fc 100644 --- a/tests/sink.rs +++ b/tests/sink.rs @@ -8,7 +8,7 @@ use std::cell::{Cell, RefCell}; use std::sync::atomic::{Ordering, AtomicBool}; use futures::{Poll, Async, Future, AsyncSink, StartSend}; -use futures::future::finished; +use futures::future::ok; use futures::stream; use futures::sync::{oneshot, mpsc}; use futures::task::{self, Task}; @@ -109,7 +109,7 @@ impl Future for StartSendFut { fn mpsc_blocking_start_send() { let (mut tx, mut rx) = mpsc::channel::(0); - futures::lazy(|| { + futures::future::lazy(|| { assert_eq!(tx.start_send(0).unwrap(), AsyncSink::Ready); let flag = Flag::new(); @@ -155,7 +155,7 @@ fn with_flush() { let (tx, rx) = oneshot::channel(); let mut block = rx.boxed(); let mut sink = Vec::new().with(|elem| { - mem::replace(&mut block, finished(()).boxed()) + mem::replace(&mut block, ok(()).boxed()) .map(move |_| elem + 1).map_err(|_| panic!()) }); diff --git a/tests/stream.rs b/tests/stream.rs index 0293c653ea0..115550157af 100644 --- a/tests/stream.rs +++ b/tests/stream.rs @@ -3,7 +3,7 @@ extern crate futures; use futures::{Poll, Future, Stream, Sink}; use futures::executor; -use futures::future::{failed, finished}; +use futures::future::{ok, err}; use futures::stream::{iter, Peekable, BoxStream}; use futures::sync::oneshot; use futures::sync::mpsc; @@ -42,8 +42,8 @@ fn map_err() { #[test] fn fold() { - assert_done(|| list().fold(0, |a, b| finished::(a + b)), Ok(6)); - assert_done(|| err_list().fold(0, |a, b| finished::(a + b)), Err(3)); + assert_done(|| list().fold(0, |a, b| ok::(a + b)), Ok(6)); + assert_done(|| err_list().fold(0, |a, b| ok::(a + b)), Err(3)); } #[test] @@ -65,7 +65,7 @@ fn filter_map() { #[test] fn and_then() { assert_done(|| list().and_then(|a| Ok(a + 1)).collect(), Ok(vec![2, 3, 4])); - assert_done(|| list().and_then(|a| failed::(a as u32)).collect(), + assert_done(|| list().and_then(|a| err::(a as u32)).collect(), Err(1)); } @@ -78,7 +78,7 @@ fn then() { #[test] fn or_else() { assert_done(|| err_list().or_else(|a| { - finished::(a as i32) + ok::(a as i32) }).collect(), Ok(vec![1, 2, 3])); } diff --git a/tests/support/mod.rs b/tests/support/mod.rs index 33d4046cb48..facc556ee9a 100755 --- a/tests/support/mod.rs +++ b/tests/support/mod.rs @@ -5,15 +5,15 @@ use std::sync::Arc; use std::thread; use futures::{Future, IntoFuture, Async, Poll}; -use futures::future::Done; +use futures::future::FutureResult; use futures::stream::Stream; use futures::executor::{self, Unpark}; use futures::task; -pub fn f_ok(a: i32) -> Done { Ok(a).into_future() } -pub fn f_err(a: u32) -> Done { Err(a).into_future() } -pub fn ok(a: i32) -> Result { Ok(a) } -pub fn err(a: u32) -> Result { Err(a) } +pub fn f_ok(a: i32) -> FutureResult { Ok(a).into_future() } +pub fn f_err(a: u32) -> FutureResult { Err(a).into_future() } +pub fn r_ok(a: i32) -> Result { Ok(a) } +pub fn r_err(a: u32) -> Result { Err(a) } pub fn assert_done(f: F, result: Result) where T: Future,