Struct Async

pub struct Async<Fut: Future> { /* private fields */ }

A wrapper class for a Future that enables usage of some std::ops traits.

This struct will implement a supported std::ops trait when <Fut as Future>::Output type implements the same std::ops trait.

Implementations

impl<Fut: Future> Async<Fut>

pub fn assignable<T: Assignable<Fut> + Future>(self) -> Async<T>

Wraps the inner Future in Async with the given Assignable type so that it can be used with Assign variants of std::ops traits.

See also assignable!.

Example

use futures_executor::block_on;
use futures::future::LocalBoxFuture;

let a = async { 40 };
let b = async { 2 };

let result = async {
  let mut a = async_ops::on(a).assignable::<LocalBoxFuture<usize>>();
  a += b;
  a.await
};

assert_eq!(42, block_on(result));

pub fn unary_op<Op: Unary<Fut>>(self, _: Op) -> Async<Op::Output>

where Op::Output: Future,

Does the given Unary operation Op on the wrapped Future in Async and returns the result in a new Async.

Example

use std::future::{ready, Ready};
use futures_executor::block_on;
use async_ops::Unary;

struct Return42;

impl<Operand> Unary<Operand> for Return42 {
  type Output = Ready<usize>;
  fn op(_: Operand) -> Self::Output {
    ready(42)
  }
}

let a = async { 2 };

let result = async {
  async_ops::on(a).unary_op(Return42).await
};

assert_eq!(42, block_on(result));

pub fn op<Rhs, Op: Binary<Fut, Rhs>>(self, _: Op, rhs: Rhs) -> Async<Op::Output>

where Op::Output: Future,

Does the given Binary operation Op on the wrapped Future in Async and the given right-hand operand and returns the result in a new Async.

See also Async::op_assign.

Example

use futures_executor::block_on;
use async_ops::Binary;

struct ReturnRhs;

impl<Lhs, Rhs> Binary<Lhs, Rhs> for ReturnRhs {
  type Output = Rhs;
  fn op(_: Lhs, rhs: Rhs) -> Self::Output {
    rhs
  }
}

let a = async { 2 };
let b = async { 42 };

let result = async {
  async_ops::on(a).op(ReturnRhs, b).await
};

assert_eq!(42, block_on(result));

pub fn op_assign<Rhs, Op: Binary<Fut, Rhs>>(&mut self, _: Op, rhs: Rhs)

where Fut: Assignable<Op::Output>, Op::Output: Future,

Does the given Binary operation Op on the wrapped Future in Async and the given right-hand operand and assigns it to self.

See also Async::op.

Example

use futures_executor::block_on;
use async_ops::Binary;

struct ReturnRhs;

impl<Lhs, Rhs> Binary<Lhs, Rhs> for ReturnRhs {
  type Output = Rhs;
  fn op(_: Lhs, rhs: Rhs) -> Self::Output {
    rhs
  }
}

let a = async { 2 };
let b = async { 42 };

let result = async {
  async_ops::assignable!(a);
  a.op_assign(ReturnRhs, b);
  a.await
};

assert_eq!(42, block_on(result));

Trait Implementations

impl<Lhs: Future, Rhs: Future> Add<Rhs> for Async<Lhs>

where Lhs::Output: Add<Rhs::Output>,

type Output = Async<AsyncAdd<Lhs, Rhs>>

The resulting type after applying the + operator.

fn add(self, rhs: Rhs) -> Self::Output

Performs the + operation.

impl<Lhs, Rhs> AddAssign<Rhs> for Async<Lhs>

where Lhs: Assignable<AsyncAdd<Lhs, Rhs>> + Future, Rhs: Future, <Lhs as Future>::Output: Add<Rhs::Output>,

fn add_assign(&mut self, rhs: Rhs)

Performs the += operation.

impl<Lhs: Future, Rhs: Future> BitAnd<Rhs> for Async<Lhs>

where Lhs::Output: BitAnd<Rhs::Output>,

type Output = Async<AsyncBitAnd<Lhs, Rhs>>

The resulting type after applying the & operator.

fn bitand(self, rhs: Rhs) -> Self::Output

Performs the & operation.

impl<Lhs, Rhs> BitAndAssign<Rhs> for Async<Lhs>

where Lhs: Assignable<AsyncBitAnd<Lhs, Rhs>> + Future, Rhs: Future, <Lhs as Future>::Output: BitAnd<Rhs::Output>,

fn bitand_assign(&mut self, rhs: Rhs)

Performs the &= operation.

impl<Lhs: Future, Rhs: Future> BitOr<Rhs> for Async<Lhs>

where Lhs::Output: BitOr<Rhs::Output>,

type Output = Async<AsyncBitOr<Lhs, Rhs>>

The resulting type after applying the | operator.

fn bitor(self, rhs: Rhs) -> Self::Output

Performs the | operation.

impl<Lhs, Rhs> BitOrAssign<Rhs> for Async<Lhs>

where Lhs: Assignable<AsyncBitOr<Lhs, Rhs>> + Future, Rhs: Future, <Lhs as Future>::Output: BitOr<Rhs::Output>,

fn bitor_assign(&mut self, rhs: Rhs)

Performs the |= operation.

impl<Lhs: Future, Rhs: Future> BitXor<Rhs> for Async<Lhs>

where Lhs::Output: BitXor<Rhs::Output>,

type Output = Async<AsyncBitXor<Lhs, Rhs>>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Rhs) -> Self::Output

Performs the ^ operation.

impl<Lhs, Rhs> BitXorAssign<Rhs> for Async<Lhs>

where Lhs: Assignable<AsyncBitXor<Lhs, Rhs>> + Future, Rhs: Future, <Lhs as Future>::Output: BitXor<Rhs::Output>,

fn bitxor_assign(&mut self, rhs: Rhs)

Performs the ^= operation.

impl<Lhs: Future, Rhs: Future> Div<Rhs> for Async<Lhs>

where Lhs::Output: Div<Rhs::Output>,

type Output = Async<AsyncDiv<Lhs, Rhs>>

The resulting type after applying the / operator.

fn div(self, rhs: Rhs) -> Self::Output

Performs the / operation.

impl<Lhs, Rhs> DivAssign<Rhs> for Async<Lhs>

where Lhs: Assignable<AsyncDiv<Lhs, Rhs>> + Future, Rhs: Future, <Lhs as Future>::Output: Div<Rhs::Output>,

fn div_assign(&mut self, rhs: Rhs)

Performs the /= operation.

impl<Fut: Future> Future for Async<Fut>

type Output = <Fut as Future>::Output

The type of value produced on completion.

fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output>

Attempts to resolve the future to a final value, registering the current task for wakeup if the value is not yet available.

impl<Lhs: Future, Rhs: Future> Mul<Rhs> for Async<Lhs>

where Lhs::Output: Mul<Rhs::Output>,

type Output = Async<AsyncMul<Lhs, Rhs>>

The resulting type after applying the * operator.

fn mul(self, rhs: Rhs) -> Self::Output

Performs the * operation.

impl<Lhs, Rhs> MulAssign<Rhs> for Async<Lhs>

where Lhs: Assignable<AsyncMul<Lhs, Rhs>> + Future, Rhs: Future, <Lhs as Future>::Output: Mul<Rhs::Output>,

fn mul_assign(&mut self, rhs: Rhs)

Performs the *= operation.

impl<Operand: Future> Neg for Async<Operand>

where Operand::Output: Neg,

type Output = Async<AsyncNeg<Operand>>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<Operand: Future> Not for Async<Operand>

where Operand::Output: Not,

type Output = Async<AsyncNot<Operand>>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<Lhs: Future, Rhs: Future> Rem<Rhs> for Async<Lhs>

where Lhs::Output: Rem<Rhs::Output>,

type Output = Async<AsyncRem<Lhs, Rhs>>

The resulting type after applying the % operator.

fn rem(self, rhs: Rhs) -> Self::Output

Performs the % operation.

impl<Lhs, Rhs> RemAssign<Rhs> for Async<Lhs>

where Lhs: Assignable<AsyncRem<Lhs, Rhs>> + Future, Rhs: Future, <Lhs as Future>::Output: Rem<Rhs::Output>,

fn rem_assign(&mut self, rhs: Rhs)

Performs the %= operation.

impl<Lhs: Future, Rhs: Future> Shl<Rhs> for Async<Lhs>

where Lhs::Output: Shl<Rhs::Output>,

type Output = Async<AsyncShl<Lhs, Rhs>>

The resulting type after applying the << operator.

fn shl(self, rhs: Rhs) -> Self::Output

Performs the << operation.

impl<Lhs, Rhs> ShlAssign<Rhs> for Async<Lhs>

where Lhs: Assignable<AsyncShl<Lhs, Rhs>> + Future, Rhs: Future, <Lhs as Future>::Output: Shl<Rhs::Output>,

fn shl_assign(&mut self, rhs: Rhs)

Performs the <<= operation.

impl<Lhs: Future, Rhs: Future> Shr<Rhs> for Async<Lhs>

where Lhs::Output: Shr<Rhs::Output>,

type Output = Async<AsyncShr<Lhs, Rhs>>

The resulting type after applying the >> operator.

fn shr(self, rhs: Rhs) -> Self::Output

Performs the >> operation.

impl<Lhs, Rhs> ShrAssign<Rhs> for Async<Lhs>

where Lhs: Assignable<AsyncShr<Lhs, Rhs>> + Future, Rhs: Future, <Lhs as Future>::Output: Shr<Rhs::Output>,

fn shr_assign(&mut self, rhs: Rhs)

Performs the >>= operation.

impl<Lhs: Future, Rhs: Future> Sub<Rhs> for Async<Lhs>

where Lhs::Output: Sub<Rhs::Output>,

type Output = Async<AsyncSub<Lhs, Rhs>>

The resulting type after applying the - operator.

fn sub(self, rhs: Rhs) -> Self::Output

Performs the - operation.

impl<Lhs, Rhs> SubAssign<Rhs> for Async<Lhs>

where Lhs: Assignable<AsyncSub<Lhs, Rhs>> + Future, Rhs: Future, <Lhs as Future>::Output: Sub<Rhs::Output>,

fn sub_assign(&mut self, rhs: Rhs)

Performs the -= operation.

impl<'__pin, Fut: Future> Unpin for Async<Fut>

where PinnedFieldsOf<__Origin<'__pin, Fut>>: Unpin,