Trait differential_dataflow::difference::Multiply

pub trait Multiply<Rhs = Self> {
    type Output;

    // Required method
    fn multiply(self, rhs: &Rhs) -> Self::Output;
}

A replacement for std::ops::Mul for types that do not implement it.

Required Associated Types

type Output

Output type per the Mul trait.

Required Methods

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

Core method per the Mul trait.

Implementations on Foreign Types

impl Multiply for i8

type Output = i8

fn multiply(self, rhs: &Self) -> Self

impl Multiply for i16

type Output = i16

fn multiply(self, rhs: &Self) -> Self

impl Multiply for i32

type Output = i32

fn multiply(self, rhs: &Self) -> Self

impl Multiply for i64

type Output = i64

fn multiply(self, rhs: &Self) -> Self

impl Multiply for i128

type Output = i128

fn multiply(self, rhs: &Self) -> Self

impl Multiply for isize

type Output = isize

fn multiply(self, rhs: &Self) -> Self

impl Multiply for u8

type Output = u8

fn multiply(self, rhs: &Self) -> Self

impl Multiply for u16

type Output = u16

fn multiply(self, rhs: &Self) -> Self

impl Multiply for u32

type Output = u32

fn multiply(self, rhs: &Self) -> Self

impl Multiply for u64

type Output = u64

fn multiply(self, rhs: &Self) -> Self

impl Multiply for u128

type Output = u128

fn multiply(self, rhs: &Self) -> Self

impl Multiply for usize

type Output = usize

fn multiply(self, rhs: &Self) -> Self

impl Multiply for Wrapping<i8>

type Output = Wrapping<i8>

fn multiply(self, rhs: &Self) -> Self

impl Multiply for Wrapping<i16>

type Output = Wrapping<i16>

fn multiply(self, rhs: &Self) -> Self

impl Multiply for Wrapping<i32>

type Output = Wrapping<i32>

fn multiply(self, rhs: &Self) -> Self

impl Multiply for Wrapping<i64>

type Output = Wrapping<i64>

fn multiply(self, rhs: &Self) -> Self

impl Multiply for Wrapping<i128>

type Output = Wrapping<i128>

fn multiply(self, rhs: &Self) -> Self

impl Multiply for Wrapping<isize>

type Output = Wrapping<isize>

fn multiply(self, rhs: &Self) -> Self

impl<T> Multiply<T> for ()

type Output = ()

fn multiply(self, rhs: &T) -> Self::Output

impl<T, A1: Multiply<T>> Multiply<T> for (A1,)

type Output = (<A1 as Multiply<T>>::Output,)

fn multiply(self, rhs: &T) -> Self::Output

impl<T, A1: Multiply<T>, B1: Multiply<T>> Multiply<T> for (A1, B1)

type Output = (<A1 as Multiply<T>>::Output, <B1 as Multiply<T>>::Output)

fn multiply(self, rhs: &T) -> Self::Output

impl<T, A1: Multiply<T>, B1: Multiply<T>, C1: Multiply<T>> Multiply<T> for (A1, B1, C1)

type Output = (<A1 as Multiply<T>>::Output, <B1 as Multiply<T>>::Output, <C1 as Multiply<T>>::Output)

fn multiply(self, rhs: &T) -> Self::Output

impl<T, A1: Multiply<T>, B1: Multiply<T>, C1: Multiply<T>, D1: Multiply<T>> Multiply<T> for (A1, B1, C1, D1)

type Output = (<A1 as Multiply<T>>::Output, <B1 as Multiply<T>>::Output, <C1 as Multiply<T>>::Output, <D1 as Multiply<T>>::Output)

fn multiply(self, rhs: &T) -> Self::Output

impl<T, R: Multiply<T>> Multiply<T> for Vec<R>

type Output = Vec<<R as Multiply<T>>::Output>

fn multiply(self, rhs: &T) -> Self::Output

Implementors

impl<T: Clone> Multiply<T> for Present

type Output = T