1 use super::assert_future;
2 use core::pin::Pin;
3 use futures_core::future::{FusedFuture, Future};
4 use futures_core::task::{Context, Poll};
5
6 /// Future for the [`ready`](ready()) function.
7 #[derive(Debug, Clone)]
8 #[must_use = "futures do nothing unless you `.await` or poll them"]
9 pub struct Ready<T>(Option<T>);
10
11 impl<T> Ready<T> {
12 /// Unwraps the value from this immediately ready future.
13 #[inline]
into_inner(mut self) -> T14 pub fn into_inner(mut self) -> T {
15 self.0.take().unwrap()
16 }
17 }
18
19 impl<T> Unpin for Ready<T> {}
20
21 impl<T> FusedFuture for Ready<T> {
is_terminated(&self) -> bool22 fn is_terminated(&self) -> bool {
23 self.0.is_none()
24 }
25 }
26
27 impl<T> Future for Ready<T> {
28 type Output = T;
29
30 #[inline]
poll(mut self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<T>31 fn poll(mut self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<T> {
32 Poll::Ready(self.0.take().expect("Ready polled after completion"))
33 }
34 }
35
36 /// Creates a future that is immediately ready with a value.
37 ///
38 /// # Examples
39 ///
40 /// ```
41 /// # futures::executor::block_on(async {
42 /// use futures::future;
43 ///
44 /// let a = future::ready(1);
45 /// assert_eq!(a.await, 1);
46 /// # });
47 /// ```
ready<T>(t: T) -> Ready<T>48 pub fn ready<T>(t: T) -> Ready<T> {
49 assert_future::<T, _>(Ready(Some(t)))
50 }
51
52 /// Create a future that is immediately ready with a success value.
53 ///
54 /// # Examples
55 ///
56 /// ```
57 /// # futures::executor::block_on(async {
58 /// use futures::future;
59 ///
60 /// let a = future::ok::<i32, i32>(1);
61 /// assert_eq!(a.await, Ok(1));
62 /// # });
63 /// ```
ok<T, E>(t: T) -> Ready<Result<T, E>>64 pub fn ok<T, E>(t: T) -> Ready<Result<T, E>> {
65 Ready(Some(Ok(t)))
66 }
67
68 /// Create a future that is immediately ready with an error value.
69 ///
70 /// # Examples
71 ///
72 /// ```
73 /// # futures::executor::block_on(async {
74 /// use futures::future;
75 ///
76 /// let a = future::err::<i32, i32>(1);
77 /// assert_eq!(a.await, Err(1));
78 /// # });
79 /// ```
err<T, E>(err: E) -> Ready<Result<T, E>>80 pub fn err<T, E>(err: E) -> Ready<Result<T, E>> {
81 Ready(Some(Err(err)))
82 }
83