Trait divrem::DivRem[−][src]

pub trait DivRem<RHS = Self>: Div<RHS> + Rem<RHS> {
    type Output;
    fn div_rem(self, other: RHS) -> Self::Output;
}

Truncated division and remainder.

Truncates the quotient and effectively rounds towards zero. The sign of the modulus is always the same as the sign of the dividend.

This is the same as the / and % operators.

This is equivalent to the quotRem function in Haskell.

Associated Types

type Output[src]

The resulting type after applying the / and % operators.

Loading content...

Required methods

fn div_rem(self, other: RHS) -> Self::Output[src]

Performs the / and % operations.

Loading content...

Implementations on Foreign Types

impl DivRem<Wrapping<i8>> for Wrapping<i8>[src]

type Output = (Self::Output, Self::Output)

fn div_rem(self, other: Self) -> Self::Output[src]

impl<'a> DivRem<Wrapping<i8>> for &'a Wrapping<i8>[src]

type Output = <Wrapping<i8> as DivRem<Wrapping<i8>>>::Output

fn div_rem(
    self,
    other: Wrapping<i8>
) -> <Wrapping<i8> as DivRem<Wrapping<i8>>>::Output[src]

impl<'a> DivRem<&'a Wrapping<i8>> for Wrapping<i8>[src]

type Output = <Wrapping<i8> as DivRem<Wrapping<i8>>>::Output

fn div_rem(
    self,
    other: &'a Wrapping<i8>
) -> <Wrapping<i8> as DivRem<Wrapping<i8>>>::Output[src]

impl<'a, 'b> DivRem<&'a Wrapping<i8>> for &'b Wrapping<i8>[src]

type Output = <Wrapping<i8> as DivRem<Wrapping<i8>>>::Output

fn div_rem(
    self,
    other: &'a Wrapping<i8>
) -> <Wrapping<i8> as DivRem<Wrapping<i8>>>::Output[src]

impl DivRem<Wrapping<i16>> for Wrapping<i16>[src]

type Output = (Self::Output, Self::Output)

fn div_rem(self, other: Self) -> Self::Output[src]

impl<'a> DivRem<Wrapping<i16>> for &'a Wrapping<i16>[src]

type Output = <Wrapping<i16> as DivRem<Wrapping<i16>>>::Output

fn div_rem(
    self,
    other: Wrapping<i16>
) -> <Wrapping<i16> as DivRem<Wrapping<i16>>>::Output[src]

impl<'a> DivRem<&'a Wrapping<i16>> for Wrapping<i16>[src]

type Output = <Wrapping<i16> as DivRem<Wrapping<i16>>>::Output

fn div_rem(
    self,
    other: &'a Wrapping<i16>
) -> <Wrapping<i16> as DivRem<Wrapping<i16>>>::Output[src]

impl<'a, 'b> DivRem<&'a Wrapping<i16>> for &'b Wrapping<i16>[src]

type Output = <Wrapping<i16> as DivRem<Wrapping<i16>>>::Output

fn div_rem(
    self,
    other: &'a Wrapping<i16>
) -> <Wrapping<i16> as DivRem<Wrapping<i16>>>::Output[src]

impl DivRem<Wrapping<i32>> for Wrapping<i32>[src]

type Output = (Self::Output, Self::Output)

fn div_rem(self, other: Self) -> Self::Output[src]

impl<'a> DivRem<Wrapping<i32>> for &'a Wrapping<i32>[src]

type Output = <Wrapping<i32> as DivRem<Wrapping<i32>>>::Output

fn div_rem(
    self,
    other: Wrapping<i32>
) -> <Wrapping<i32> as DivRem<Wrapping<i32>>>::Output[src]

impl<'a> DivRem<&'a Wrapping<i32>> for Wrapping<i32>[src]

type Output = <Wrapping<i32> as DivRem<Wrapping<i32>>>::Output

fn div_rem(
    self,
    other: &'a Wrapping<i32>
) -> <Wrapping<i32> as DivRem<Wrapping<i32>>>::Output[src]

impl<'a, 'b> DivRem<&'a Wrapping<i32>> for &'b Wrapping<i32>[src]

type Output = <Wrapping<i32> as DivRem<Wrapping<i32>>>::Output

fn div_rem(
    self,
    other: &'a Wrapping<i32>
) -> <Wrapping<i32> as DivRem<Wrapping<i32>>>::Output[src]

impl DivRem<Wrapping<i64>> for Wrapping<i64>[src]

type Output = (Self::Output, Self::Output)

fn div_rem(self, other: Self) -> Self::Output[src]

impl<'a> DivRem<Wrapping<i64>> for &'a Wrapping<i64>[src]

type Output = <Wrapping<i64> as DivRem<Wrapping<i64>>>::Output

fn div_rem(
    self,
    other: Wrapping<i64>
) -> <Wrapping<i64> as DivRem<Wrapping<i64>>>::Output[src]

impl<'a> DivRem<&'a Wrapping<i64>> for Wrapping<i64>[src]

type Output = <Wrapping<i64> as DivRem<Wrapping<i64>>>::Output

fn div_rem(
    self,
    other: &'a Wrapping<i64>
) -> <Wrapping<i64> as DivRem<Wrapping<i64>>>::Output[src]

impl<'a, 'b> DivRem<&'a Wrapping<i64>> for &'b Wrapping<i64>[src]

type Output = <Wrapping<i64> as DivRem<Wrapping<i64>>>::Output

fn div_rem(
    self,
    other: &'a Wrapping<i64>
) -> <Wrapping<i64> as DivRem<Wrapping<i64>>>::Output[src]

impl DivRem<Wrapping<i128>> for Wrapping<i128>[src]

type Output = (Self::Output, Self::Output)

fn div_rem(self, other: Self) -> Self::Output[src]

impl<'a> DivRem<Wrapping<i128>> for &'a Wrapping<i128>[src]

type Output = <Wrapping<i128> as DivRem<Wrapping<i128>>>::Output

fn div_rem(
    self,
    other: Wrapping<i128>
) -> <Wrapping<i128> as DivRem<Wrapping<i128>>>::Output[src]

impl<'a> DivRem<&'a Wrapping<i128>> for Wrapping<i128>[src]

type Output = <Wrapping<i128> as DivRem<Wrapping<i128>>>::Output

fn div_rem(
    self,
    other: &'a Wrapping<i128>
) -> <Wrapping<i128> as DivRem<Wrapping<i128>>>::Output[src]

impl<'a, 'b> DivRem<&'a Wrapping<i128>> for &'b Wrapping<i128>[src]

type Output = <Wrapping<i128> as DivRem<Wrapping<i128>>>::Output

fn div_rem(
    self,
    other: &'a Wrapping<i128>
) -> <Wrapping<i128> as DivRem<Wrapping<i128>>>::Output[src]

impl DivRem<Wrapping<isize>> for Wrapping<isize>[src]

type Output = (Self::Output, Self::Output)

fn div_rem(self, other: Self) -> Self::Output[src]

impl<'a> DivRem<Wrapping<isize>> for &'a Wrapping<isize>[src]

type Output = <Wrapping<isize> as DivRem<Wrapping<isize>>>::Output

fn div_rem(
    self,
    other: Wrapping<isize>
) -> <Wrapping<isize> as DivRem<Wrapping<isize>>>::Output[src]

impl<'a> DivRem<&'a Wrapping<isize>> for Wrapping<isize>[src]

type Output = <Wrapping<isize> as DivRem<Wrapping<isize>>>::Output

fn div_rem(
    self,
    other: &'a Wrapping<isize>
) -> <Wrapping<isize> as DivRem<Wrapping<isize>>>::Output[src]

impl<'a, 'b> DivRem<&'a Wrapping<isize>> for &'b Wrapping<isize>[src]

type Output = <Wrapping<isize> as DivRem<Wrapping<isize>>>::Output

fn div_rem(
    self,
    other: &'a Wrapping<isize>
) -> <Wrapping<isize> as DivRem<Wrapping<isize>>>::Output[src]

impl DivRem<Wrapping<u8>> for Wrapping<u8>[src]

type Output = (Self::Output, Self::Output)

fn div_rem(self, other: Self) -> Self::Output[src]

impl<'a> DivRem<Wrapping<u8>> for &'a Wrapping<u8>[src]

type Output = <Wrapping<u8> as DivRem<Wrapping<u8>>>::Output

fn div_rem(
    self,
    other: Wrapping<u8>
) -> <Wrapping<u8> as DivRem<Wrapping<u8>>>::Output[src]

impl<'a> DivRem<&'a Wrapping<u8>> for Wrapping<u8>[src]

type Output = <Wrapping<u8> as DivRem<Wrapping<u8>>>::Output

fn div_rem(
    self,
    other: &'a Wrapping<u8>
) -> <Wrapping<u8> as DivRem<Wrapping<u8>>>::Output[src]

impl<'a, 'b> DivRem<&'a Wrapping<u8>> for &'b Wrapping<u8>[src]

type Output = <Wrapping<u8> as DivRem<Wrapping<u8>>>::Output

fn div_rem(
    self,
    other: &'a Wrapping<u8>
) -> <Wrapping<u8> as DivRem<Wrapping<u8>>>::Output[src]

impl DivRem<Wrapping<u16>> for Wrapping<u16>[src]

type Output = (Self::Output, Self::Output)

fn div_rem(self, other: Self) -> Self::Output[src]

impl<'a> DivRem<Wrapping<u16>> for &'a Wrapping<u16>[src]

type Output = <Wrapping<u16> as DivRem<Wrapping<u16>>>::Output

fn div_rem(
    self,
    other: Wrapping<u16>
) -> <Wrapping<u16> as DivRem<Wrapping<u16>>>::Output[src]

impl<'a> DivRem<&'a Wrapping<u16>> for Wrapping<u16>[src]

type Output = <Wrapping<u16> as DivRem<Wrapping<u16>>>::Output

fn div_rem(
    self,
    other: &'a Wrapping<u16>
) -> <Wrapping<u16> as DivRem<Wrapping<u16>>>::Output[src]

impl<'a, 'b> DivRem<&'a Wrapping<u16>> for &'b Wrapping<u16>[src]

type Output = <Wrapping<u16> as DivRem<Wrapping<u16>>>::Output

fn div_rem(
    self,
    other: &'a Wrapping<u16>
) -> <Wrapping<u16> as DivRem<Wrapping<u16>>>::Output[src]

impl DivRem<Wrapping<u32>> for Wrapping<u32>[src]

type Output = (Self::Output, Self::Output)

fn div_rem(self, other: Self) -> Self::Output[src]

impl<'a> DivRem<Wrapping<u32>> for &'a Wrapping<u32>[src]

type Output = <Wrapping<u32> as DivRem<Wrapping<u32>>>::Output

fn div_rem(
    self,
    other: Wrapping<u32>
) -> <Wrapping<u32> as DivRem<Wrapping<u32>>>::Output[src]

impl<'a> DivRem<&'a Wrapping<u32>> for Wrapping<u32>[src]

type Output = <Wrapping<u32> as DivRem<Wrapping<u32>>>::Output

fn div_rem(
    self,
    other: &'a Wrapping<u32>
) -> <Wrapping<u32> as DivRem<Wrapping<u32>>>::Output[src]

impl<'a, 'b> DivRem<&'a Wrapping<u32>> for &'b Wrapping<u32>[src]

type Output = <Wrapping<u32> as DivRem<Wrapping<u32>>>::Output

fn div_rem(
    self,
    other: &'a Wrapping<u32>
) -> <Wrapping<u32> as DivRem<Wrapping<u32>>>::Output[src]

impl DivRem<Wrapping<u64>> for Wrapping<u64>[src]

type Output = (Self::Output, Self::Output)

fn div_rem(self, other: Self) -> Self::Output[src]

impl<'a> DivRem<Wrapping<u64>> for &'a Wrapping<u64>[src]

type Output = <Wrapping<u64> as DivRem<Wrapping<u64>>>::Output

fn div_rem(
    self,
    other: Wrapping<u64>
) -> <Wrapping<u64> as DivRem<Wrapping<u64>>>::Output[src]

impl<'a> DivRem<&'a Wrapping<u64>> for Wrapping<u64>[src]

type Output = <Wrapping<u64> as DivRem<Wrapping<u64>>>::Output

fn div_rem(
    self,
    other: &'a Wrapping<u64>
) -> <Wrapping<u64> as DivRem<Wrapping<u64>>>::Output[src]

impl<'a, 'b> DivRem<&'a Wrapping<u64>> for &'b Wrapping<u64>[src]

type Output = <Wrapping<u64> as DivRem<Wrapping<u64>>>::Output

fn div_rem(
    self,
    other: &'a Wrapping<u64>
) -> <Wrapping<u64> as DivRem<Wrapping<u64>>>::Output[src]

impl DivRem<Wrapping<u128>> for Wrapping<u128>[src]

type Output = (Self::Output, Self::Output)

fn div_rem(self, other: Self) -> Self::Output[src]

impl<'a> DivRem<Wrapping<u128>> for &'a Wrapping<u128>[src]

type Output = <Wrapping<u128> as DivRem<Wrapping<u128>>>::Output

fn div_rem(
    self,
    other: Wrapping<u128>
) -> <Wrapping<u128> as DivRem<Wrapping<u128>>>::Output[src]

impl<'a> DivRem<&'a Wrapping<u128>> for Wrapping<u128>[src]

type Output = <Wrapping<u128> as DivRem<Wrapping<u128>>>::Output

fn div_rem(
    self,
    other: &'a Wrapping<u128>
) -> <Wrapping<u128> as DivRem<Wrapping<u128>>>::Output[src]

impl<'a, 'b> DivRem<&'a Wrapping<u128>> for &'b Wrapping<u128>[src]

type Output = <Wrapping<u128> as DivRem<Wrapping<u128>>>::Output

fn div_rem(
    self,
    other: &'a Wrapping<u128>
) -> <Wrapping<u128> as DivRem<Wrapping<u128>>>::Output[src]

impl DivRem<Wrapping<usize>> for Wrapping<usize>[src]

type Output = (Self::Output, Self::Output)

fn div_rem(self, other: Self) -> Self::Output[src]

impl<'a> DivRem<Wrapping<usize>> for &'a Wrapping<usize>[src]

type Output = <Wrapping<usize> as DivRem<Wrapping<usize>>>::Output

fn div_rem(
    self,
    other: Wrapping<usize>
) -> <Wrapping<usize> as DivRem<Wrapping<usize>>>::Output[src]

impl<'a> DivRem<&'a Wrapping<usize>> for Wrapping<usize>[src]

type Output = <Wrapping<usize> as DivRem<Wrapping<usize>>>::Output

fn div_rem(
    self,
    other: &'a Wrapping<usize>
) -> <Wrapping<usize> as DivRem<Wrapping<usize>>>::Output[src]

impl<'a, 'b> DivRem<&'a Wrapping<usize>> for &'b Wrapping<usize>[src]

type Output = <Wrapping<usize> as DivRem<Wrapping<usize>>>::Output

fn div_rem(
    self,
    other: &'a Wrapping<usize>
) -> <Wrapping<usize> as DivRem<Wrapping<usize>>>::Output[src]

Loading content...

Implementors

impl DivRem<i8> for i8[src]

type Output = (Self::Output, Self::Output)

fn div_rem(self, other: Self) -> Self::Output[src]

impl DivRem<i16> for i16[src]

type Output = (Self::Output, Self::Output)

fn div_rem(self, other: Self) -> Self::Output[src]

impl DivRem<i32> for i32[src]

type Output = (Self::Output, Self::Output)

fn div_rem(self, other: Self) -> Self::Output[src]

impl DivRem<i64> for i64[src]

type Output = (Self::Output, Self::Output)

fn div_rem(self, other: Self) -> Self::Output[src]

impl DivRem<i128> for i128[src]

type Output = (Self::Output, Self::Output)

fn div_rem(self, other: Self) -> Self::Output[src]

impl DivRem<isize> for isize[src]

type Output = (Self::Output, Self::Output)

fn div_rem(self, other: Self) -> Self::Output[src]

impl DivRem<u8> for u8[src]

type Output = (Self::Output, Self::Output)

fn div_rem(self, other: Self) -> Self::Output[src]

impl DivRem<u16> for u16[src]

type Output = (Self::Output, Self::Output)

fn div_rem(self, other: Self) -> Self::Output[src]

impl DivRem<u32> for u32[src]

type Output = (Self::Output, Self::Output)

fn div_rem(self, other: Self) -> Self::Output[src]

impl DivRem<u64> for u64[src]

type Output = (Self::Output, Self::Output)

fn div_rem(self, other: Self) -> Self::Output[src]

impl DivRem<u128> for u128[src]

type Output = (Self::Output, Self::Output)

fn div_rem(self, other: Self) -> Self::Output[src]

impl DivRem<usize> for usize[src]

type Output = (Self::Output, Self::Output)

fn div_rem(self, other: Self) -> Self::Output[src]

impl<'a> DivRem<&'a i8> for i8[src]

type Output = <i8 as DivRem<i8>>::Output

fn div_rem(self, other: &'a i8) -> <i8 as DivRem<i8>>::Output[src]

impl<'a> DivRem<&'a i16> for i16[src]

type Output = <i16 as DivRem<i16>>::Output

fn div_rem(self, other: &'a i16) -> <i16 as DivRem<i16>>::Output[src]

impl<'a> DivRem<&'a i32> for i32[src]

type Output = <i32 as DivRem<i32>>::Output

fn div_rem(self, other: &'a i32) -> <i32 as DivRem<i32>>::Output[src]

impl<'a> DivRem<&'a i64> for i64[src]

type Output = <i64 as DivRem<i64>>::Output

fn div_rem(self, other: &'a i64) -> <i64 as DivRem<i64>>::Output[src]

impl<'a> DivRem<&'a i128> for i128[src]

type Output = <i128 as DivRem<i128>>::Output

fn div_rem(self, other: &'a i128) -> <i128 as DivRem<i128>>::Output[src]

impl<'a> DivRem<&'a isize> for isize[src]

type Output = <isize as DivRem<isize>>::Output

fn div_rem(self, other: &'a isize) -> <isize as DivRem<isize>>::Output[src]

impl<'a> DivRem<&'a u8> for u8[src]

type Output = <u8 as DivRem<u8>>::Output

fn div_rem(self, other: &'a u8) -> <u8 as DivRem<u8>>::Output[src]

impl<'a> DivRem<&'a u16> for u16[src]

type Output = <u16 as DivRem<u16>>::Output

fn div_rem(self, other: &'a u16) -> <u16 as DivRem<u16>>::Output[src]

impl<'a> DivRem<&'a u32> for u32[src]

type Output = <u32 as DivRem<u32>>::Output

fn div_rem(self, other: &'a u32) -> <u32 as DivRem<u32>>::Output[src]

impl<'a> DivRem<&'a u64> for u64[src]

type Output = <u64 as DivRem<u64>>::Output

fn div_rem(self, other: &'a u64) -> <u64 as DivRem<u64>>::Output[src]

impl<'a> DivRem<&'a u128> for u128[src]

type Output = <u128 as DivRem<u128>>::Output

fn div_rem(self, other: &'a u128) -> <u128 as DivRem<u128>>::Output[src]

impl<'a> DivRem<&'a usize> for usize[src]

type Output = <usize as DivRem<usize>>::Output

fn div_rem(self, other: &'a usize) -> <usize as DivRem<usize>>::Output[src]

impl<'a> DivRem<i8> for &'a i8[src]

type Output = <i8 as DivRem<i8>>::Output

fn div_rem(self, other: i8) -> <i8 as DivRem<i8>>::Output[src]

impl<'a> DivRem<i16> for &'a i16[src]

type Output = <i16 as DivRem<i16>>::Output

fn div_rem(self, other: i16) -> <i16 as DivRem<i16>>::Output[src]

impl<'a> DivRem<i32> for &'a i32[src]

type Output = <i32 as DivRem<i32>>::Output

fn div_rem(self, other: i32) -> <i32 as DivRem<i32>>::Output[src]

impl<'a> DivRem<i64> for &'a i64[src]

type Output = <i64 as DivRem<i64>>::Output

fn div_rem(self, other: i64) -> <i64 as DivRem<i64>>::Output[src]

impl<'a> DivRem<i128> for &'a i128[src]

type Output = <i128 as DivRem<i128>>::Output

fn div_rem(self, other: i128) -> <i128 as DivRem<i128>>::Output[src]

impl<'a> DivRem<isize> for &'a isize[src]

type Output = <isize as DivRem<isize>>::Output

fn div_rem(self, other: isize) -> <isize as DivRem<isize>>::Output[src]

impl<'a> DivRem<u8> for &'a u8[src]

type Output = <u8 as DivRem<u8>>::Output

fn div_rem(self, other: u8) -> <u8 as DivRem<u8>>::Output[src]

impl<'a> DivRem<u16> for &'a u16[src]

type Output = <u16 as DivRem<u16>>::Output

fn div_rem(self, other: u16) -> <u16 as DivRem<u16>>::Output[src]

impl<'a> DivRem<u32> for &'a u32[src]

type Output = <u32 as DivRem<u32>>::Output

fn div_rem(self, other: u32) -> <u32 as DivRem<u32>>::Output[src]

impl<'a> DivRem<u64> for &'a u64[src]

type Output = <u64 as DivRem<u64>>::Output

fn div_rem(self, other: u64) -> <u64 as DivRem<u64>>::Output[src]

impl<'a> DivRem<u128> for &'a u128[src]

type Output = <u128 as DivRem<u128>>::Output

fn div_rem(self, other: u128) -> <u128 as DivRem<u128>>::Output[src]

impl<'a> DivRem<usize> for &'a usize[src]

type Output = <usize as DivRem<usize>>::Output

fn div_rem(self, other: usize) -> <usize as DivRem<usize>>::Output[src]

impl<'a, 'b> DivRem<&'a i8> for &'b i8[src]

type Output = <i8 as DivRem<i8>>::Output

fn div_rem(self, other: &'a i8) -> <i8 as DivRem<i8>>::Output[src]

impl<'a, 'b> DivRem<&'a i16> for &'b i16[src]

type Output = <i16 as DivRem<i16>>::Output

fn div_rem(self, other: &'a i16) -> <i16 as DivRem<i16>>::Output[src]

impl<'a, 'b> DivRem<&'a i32> for &'b i32[src]

type Output = <i32 as DivRem<i32>>::Output

fn div_rem(self, other: &'a i32) -> <i32 as DivRem<i32>>::Output[src]

impl<'a, 'b> DivRem<&'a i64> for &'b i64[src]

type Output = <i64 as DivRem<i64>>::Output

fn div_rem(self, other: &'a i64) -> <i64 as DivRem<i64>>::Output[src]

impl<'a, 'b> DivRem<&'a i128> for &'b i128[src]

type Output = <i128 as DivRem<i128>>::Output

fn div_rem(self, other: &'a i128) -> <i128 as DivRem<i128>>::Output[src]

impl<'a, 'b> DivRem<&'a isize> for &'b isize[src]

type Output = <isize as DivRem<isize>>::Output

fn div_rem(self, other: &'a isize) -> <isize as DivRem<isize>>::Output[src]

impl<'a, 'b> DivRem<&'a u8> for &'b u8[src]

type Output = <u8 as DivRem<u8>>::Output

fn div_rem(self, other: &'a u8) -> <u8 as DivRem<u8>>::Output[src]

impl<'a, 'b> DivRem<&'a u16> for &'b u16[src]

type Output = <u16 as DivRem<u16>>::Output

fn div_rem(self, other: &'a u16) -> <u16 as DivRem<u16>>::Output[src]

impl<'a, 'b> DivRem<&'a u32> for &'b u32[src]

type Output = <u32 as DivRem<u32>>::Output

fn div_rem(self, other: &'a u32) -> <u32 as DivRem<u32>>::Output[src]

impl<'a, 'b> DivRem<&'a u64> for &'b u64[src]

type Output = <u64 as DivRem<u64>>::Output

fn div_rem(self, other: &'a u64) -> <u64 as DivRem<u64>>::Output[src]

impl<'a, 'b> DivRem<&'a u128> for &'b u128[src]

type Output = <u128 as DivRem<u128>>::Output

fn div_rem(self, other: &'a u128) -> <u128 as DivRem<u128>>::Output[src]

impl<'a, 'b> DivRem<&'a usize> for &'b usize[src]

type Output = <usize as DivRem<usize>>::Output

fn div_rem(self, other: &'a usize) -> <usize as DivRem<usize>>::Output[src]

Loading content...