Trait Binary

pub trait Binary<Lhs, Rhs> {
    type Output;

    // Required method
    fn op(lhs: Lhs, rhs: Rhs) -> Self::Output;

    // Provided method
    fn op_assign(lhs: &mut Lhs, rhs: Rhs)
       where Lhs: Assignable<Self::Output> { ... }
}

Trait that represents a binary operation on the left-hand operand of type Lhs and the right-hand operand of type Rhs that returns the result of type Output.

See Async::op and Async::op_assign.

Required Associated Types

type Output

The resulting type after applying the binary operation.

Required Methods

fn op(lhs: Lhs, rhs: Rhs) -> Self::Output

Do the binary operation on given operands.

Provided Methods

fn op_assign(lhs: &mut Lhs, rhs: Rhs)

where Lhs: Assignable<Self::Output>,

Do the binary operation on given operands and assign the result to the lhs operand.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

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

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

type Output = AsyncAdd<Lhs, Rhs>

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

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

type Output = AsyncBitAnd<Lhs, Rhs>

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

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

type Output = AsyncBitOr<Lhs, Rhs>

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

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

type Output = AsyncBitXor<Lhs, Rhs>

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

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

type Output = AsyncDiv<Lhs, Rhs>

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

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

type Output = AsyncMul<Lhs, Rhs>

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

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

type Output = AsyncRem<Lhs, Rhs>

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

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

type Output = AsyncShl<Lhs, Rhs>

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

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

type Output = AsyncShr<Lhs, Rhs>

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

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

type Output = AsyncSub<Lhs, Rhs>