Trait opendp::traits::FallibleSub

pub trait FallibleSub<Rhs = Self> {
    type Output;
    fn sub(self, rhs: Rhs) -> Fallible<Self::Output>;
}

Associated Types

type Output

Required methods

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

Implementations on Foreign Types

impl<Rhs> FallibleSub<Rhs> for u8 where
    u8: Sub<Rhs, Output = u8>, 

type Output = u8

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

impl<Rhs> FallibleSub<Rhs> for u16 where
    u16: Sub<Rhs, Output = u16>, 

type Output = u16

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

impl<Rhs> FallibleSub<Rhs> for u32 where
    u32: Sub<Rhs, Output = u32>, 

type Output = u32

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

impl<Rhs> FallibleSub<Rhs> for u64 where
    u64: Sub<Rhs, Output = u64>, 

type Output = u64

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

impl<Rhs> FallibleSub<Rhs> for u128 where
    u128: Sub<Rhs, Output = u128>, 

type Output = u128

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

impl<Rhs> FallibleSub<Rhs> for i8 where
    i8: Sub<Rhs, Output = i8>, 

type Output = i8

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

impl<Rhs> FallibleSub<Rhs> for i16 where
    i16: Sub<Rhs, Output = i16>, 

type Output = i16

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

impl<Rhs> FallibleSub<Rhs> for i32 where
    i32: Sub<Rhs, Output = i32>, 

type Output = i32

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

impl<Rhs> FallibleSub<Rhs> for i64 where
    i64: Sub<Rhs, Output = i64>, 

type Output = i64

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

impl<Rhs> FallibleSub<Rhs> for i128 where
    i128: Sub<Rhs, Output = i128>, 

type Output = i128

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

impl<Rhs> FallibleSub<Rhs> for f32 where
    f32: Sub<Rhs, Output = f32>, 

type Output = f32

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

impl<Rhs> FallibleSub<Rhs> for f64 where
    f64: Sub<Rhs, Output = f64>, 

type Output = f64

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

impl<T0, T1, Rhs0, Rhs1> FallibleSub<(Rhs0, Rhs1)> for (T0, T1) where
    T0: Sub<Rhs0>,
    T1: Sub<Rhs1>, 

type Output = (T0::Output, T1::Output)

fn sub(self, rhs: (Rhs0, Rhs1)) -> Fallible<Self::Output>

impl<'a, T0, T1, Rhs0, Rhs1> FallibleSub<&'a (Rhs0, Rhs1)> for (T0, T1) where
    T0: Sub<&'a Rhs0>,
    T1: Sub<&'a Rhs1>, 

type Output = (T0::Output, T1::Output)

fn sub(self, rhs: &'a (Rhs0, Rhs1)) -> Fallible<Self::Output>

Implementors