impl<T> Poll<T>

fn map<U, F>(self: Self, f: F) -> Poll<U>
where
    F: FnOnce(T) -> U

Maps a Poll<T> to Poll<U> by applying a function to a contained value.

Examples

Converts a Poll<String> into a Poll<[usize]>, consuming the original:

# use core::task::Poll;
let poll_some_string = Poll::Ready(String::from("Hello, World!"));
// `Poll::map` takes self *by value*, consuming `poll_some_string`
let poll_some_len = poll_some_string.map(|s| s.len());

assert_eq!(poll_some_len, Poll::Ready(13));

const fn is_ready(self: &Self) -> bool

Returns true if the poll is a Poll::Ready value.

Examples

# use core::task::Poll;
let x: Poll<u32> = Poll::Ready(2);
assert_eq!(x.is_ready(), true);

let x: Poll<u32> = Poll::Pending;
assert_eq!(x.is_ready(), false);

const fn is_pending(self: &Self) -> bool

Returns true if the poll is a Pending value.

Examples

# use core::task::Poll;
let x: Poll<u32> = Poll::Ready(2);
assert_eq!(x.is_pending(), false);

let x: Poll<u32> = Poll::Pending;
assert_eq!(x.is_pending(), true);

impl<T, E> Poll<Option<Result<T, E>>>

fn map_ok<U, F>(self: Self, f: F) -> Poll<Option<Result<U, E>>>
where
    F: FnOnce(T) -> U

Maps a Poll<Option<Result<T, E>>> to Poll<Option<Result<U, E>>> by applying a function to a contained Poll::Ready(Some(Ok)) value, leaving all other variants untouched.

This function can be used to compose the results of two functions.

Examples

# use core::task::Poll;
let res: Poll<Option<Result<u8, _>>> = Poll::Ready(Some("12".parse()));
let squared = res.map_ok(|n| n * n);
assert_eq!(squared, Poll::Ready(Some(Ok(144))));

fn map_err<U, F>(self: Self, f: F) -> Poll<Option<Result<T, U>>>
where
    F: FnOnce(E) -> U

Maps a Poll::Ready<Option<Result<T, E>>> to Poll::Ready<Option<Result<T, F>>> by applying a function to a contained Poll::Ready(Some(Err)) value, leaving all other variants untouched.

This function can be used to pass through a successful result while handling an error.

Examples

# use core::task::Poll;
let res: Poll<Option<Result<u8, _>>> = Poll::Ready(Some("oops".parse()));
let res = res.map_err(|_| 0_u8);
assert_eq!(res, Poll::Ready(Some(Err(0))));

impl<T, E> Poll<Result<T, E>>

fn map_ok<U, F>(self: Self, f: F) -> Poll<Result<U, E>>
where
    F: FnOnce(T) -> U

Maps a Poll<Result<T, E>> to Poll<Result<U, E>> by applying a function to a contained Poll::Ready(Ok) value, leaving all other variants untouched.

This function can be used to compose the results of two functions.

Examples

# use core::task::Poll;
let res: Poll<Result<u8, _>> = Poll::Ready("12".parse());
let squared = res.map_ok(|n| n * n);
assert_eq!(squared, Poll::Ready(Ok(144)));

fn map_err<U, F>(self: Self, f: F) -> Poll<Result<T, U>>
where
    F: FnOnce(E) -> U

Maps a Poll::Ready<Result<T, E>> to Poll::Ready<Result<T, U>> by applying a function to a contained Poll::Ready(Err) value, leaving all other variants untouched.

This function can be used to pass through a successful result while handling an error.

Examples

# use core::task::Poll;
let res: Poll<Result<u8, _>> = Poll::Ready("oops".parse());
let res = res.map_err(|_| 0_u8);
assert_eq!(res, Poll::Ready(Err(0)));

impl<T> Any for Poll<T>

fn type_id(self: &Self) -> TypeId

impl<T> Borrow for Poll<T>

fn borrow(self: &Self) -> &T

impl<T> BorrowMut for Poll<T>

fn borrow_mut(self: &mut Self) -> &mut T

impl<T> CloneToUninit for Poll<T>

unsafe fn clone_to_uninit(self: &Self, dest: *mut u8)

impl<T> Freeze for Poll<T>

impl<T> From for Poll<T>

fn from(t: T) -> Poll<T>

Moves the value into a Poll::Ready to make a Poll<T>.

Example

# use core::task::Poll;
assert_eq!(Poll::from(true), Poll::Ready(true));

impl<T> From for Poll<T>

fn from(t: T) -> T

Returns the argument unchanged.

impl<T> From for Poll<T>

fn from(t: never) -> T

impl<T> RefUnwindSafe for Poll<T>

impl<T> Send for Poll<T>

impl<T> StructuralPartialEq for Poll<T>

impl<T> Sync for Poll<T>

impl<T> Unpin for Poll<T>

impl<T> UnsafeUnpin for Poll<T>

impl<T> UnwindSafe for Poll<T>

impl<T, E> Try for Poll<Option<Result<T, E>>>

fn from_output(c: <Self as >::Output) -> Self

fn branch(self: Self) -> ControlFlow<<Self as >::Residual, <Self as >::Output>

impl<T, E> Try for Poll<Result<T, E>>

fn from_output(c: <Self as >::Output) -> Self

fn branch(self: Self) -> ControlFlow<<Self as >::Residual, <Self as >::Output>

impl<T, E, F: From<E>> FromResidual for Poll<Option<Result<T, F>>>

fn from_residual(x: Result<Infallible, E>) -> Self

impl<T, E, F: From<E>> FromResidual for Poll<Result<T, F>>

fn from_residual(x: Result<Infallible, E>) -> Self

impl<T, U> Into for Poll<T>

fn into(self: Self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

impl<T, U> TryFrom for Poll<T>

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

impl<T, U> TryInto for Poll<T>

fn try_into(self: Self) -> Result<U, <U as TryFrom<T>>::Error>

impl<T: $crate::clone::Clone> Clone for Poll<T>

fn clone(self: &Self) -> Poll<T>

impl<T: $crate::cmp::Eq> Eq for Poll<T>

impl<T: $crate::cmp::Ord> Ord for Poll<T>

fn cmp(self: &Self, other: &Poll<T>) -> Ordering

impl<T: $crate::cmp::PartialEq> PartialEq for Poll<T>

fn eq(self: &Self, other: &Poll<T>) -> bool

impl<T: $crate::cmp::PartialOrd> PartialOrd for Poll<T>

fn partial_cmp(self: &Self, other: &Poll<T>) -> Option<Ordering>

impl<T: $crate::fmt::Debug> Debug for Poll<T>

fn fmt(self: &Self, f: &mut Formatter<'_>) -> Result

impl<T: $crate::hash::Hash> Hash for Poll<T>

fn hash<__H: $crate::hash::Hasher>(self: &Self, state: &mut __H)

impl<T: $crate::marker::Copy> Copy for Poll<T>