Enum Poll

#[must_use = "this `Poll` may be a `Pending` variant, which should be handled"]
pub enum Poll<T>

Indicates whether a value is available or if the current task has been scheduled to receive a wakeup instead.

This is returned by Future::poll.

Variants

Ready(T)

Represents that a value is immediately ready.

Pending

Represents that a value is not ready yet.

When a function returns Pending, the function must also ensure that the current task is scheduled to be awoken when progress can be made.

Implementations

impl<T> Poll<Option<T>>

fn async_gen_ready(t: T) -> Self

A helper function for internal desugaring -- produces Ready(Some(t)), which corresponds to the async iterator yielding a value.

const PENDING: Self = Poll::Pending;

A helper constant for internal desugaring -- produces Pending, which corresponds to the async iterator pending on an .await.

const FINISHED: Self = _;

A helper constant for internal desugaring -- produces Ready(None), which corresponds to the async iterator finishing its iteration.

impl<T> Poll<T>

fn map<U, F>(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) -> 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) -> 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, 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, 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, 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, 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)));

Trait Implementations

impl<T> From<T> 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, E> Try for Poll<Option<Result<T, E>>>

type Output = Poll<Option<T>>;
type Residual = Result<never, E>;
fn from_output(c: Self::Output) -> Self
fn branch(self) -> ControlFlow<Self::Residual, Self::Output>

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

type Output = Poll<T>;
type Residual = Result<never, E>;
fn from_output(c: Self::Output) -> Self
fn branch(self) -> ControlFlow<Self::Residual, Self::Output>

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

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

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

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

impl<T: Clone> Clone for Poll<T>

fn clone(&self) -> Self

impl<T: Copy> Copy for Poll<T>

impl<T: Debug> Debug for Poll<T>

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

impl<T: Eq> Eq for Poll<T>

fn assert_fields_are_eq(&self)

impl<T: Hash> Hash for Poll<T>

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

impl<T: Ord> Ord for Poll<T>

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

impl<T: PartialEq> PartialEq for Poll<T>

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

impl<T: PartialEq> StructuralPartialEq for Poll<T>

impl<T: PartialOrd> PartialOrd for Poll<T>

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

Auto Trait Implementations

impl<T> Freeze for Poll<T> where T: Freeze,

impl<T> RefUnwindSafe for Poll<T> where T: RefUnwindSafe,

impl<T> Send for Poll<T> where T: Send,

impl<T> Sync for Poll<T> where T: Sync,

impl<T> Unpin for Poll<T> where T: Unpin,

impl<T> UnsafeUnpin for Poll<T> where T: UnsafeUnpin,

impl<T> UnwindSafe for Poll<T> where T: UnwindSafe,

Blanket Implementations

impl<T> Any for Poll<T> where T: 'static + ?Sized,

fn type_id(&self) -> TypeId

impl<T> Borrow<T> for Poll<T> where T: ?Sized,

fn borrow(&self) -> &T

impl<T> BorrowMut<T> for Poll<T> where T: ?Sized,

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

impl<T> CloneToUninit for Poll<T> where T: Clone,

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

impl<T> From<T> for Poll<T>

fn from(t: T) -> T

Returns the argument unchanged.

impl<T> Printable for Poll<T> where T: Copy + Debug,

impl<T> SizeHint for Poll<T> where T: ?Sized,

fn lower_bound(&self) -> usize
fn upper_bound(&self) -> Option<usize>

impl<T> SizedTypeProperties for Poll<T>

impl<T, U> Into<U> for Poll<T> where U: From<T>,

fn into(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<U> for Poll<T> where U: Into<T>,

type Error = never;
fn try_from(value: U) -> Result<T, never>

impl<T, U> TryInto<U> for Poll<T> where U: TryFrom<T>,

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