Trait divrem::DivRem

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

The resulting type after applying the / and % operators.

Required Methods

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

Performs the / and % operations.

Implementations on Foreign Types

impl DivRem for Wrapping<i8>

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

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

impl<'a> DivRem<Wrapping<i8>> for &'a Wrapping<i8>

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

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

impl<'a> DivRem<&'a Wrapping<i8>> for Wrapping<i8>

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

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

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

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

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

impl DivRem for Wrapping<i16>

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

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

impl<'a> DivRem<Wrapping<i16>> for &'a Wrapping<i16>

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

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

impl<'a> DivRem<&'a Wrapping<i16>> for Wrapping<i16>

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

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

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

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

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

impl DivRem for Wrapping<i32>

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

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

impl<'a> DivRem<Wrapping<i32>> for &'a Wrapping<i32>

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

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

impl<'a> DivRem<&'a Wrapping<i32>> for Wrapping<i32>

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

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

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

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

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

impl DivRem for Wrapping<i64>

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

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

impl<'a> DivRem<Wrapping<i64>> for &'a Wrapping<i64>

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

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

impl<'a> DivRem<&'a Wrapping<i64>> for Wrapping<i64>

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

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

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

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

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

impl DivRem for Wrapping<i128>

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

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

impl<'a> DivRem<Wrapping<i128>> for &'a Wrapping<i128>

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

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

impl<'a> DivRem<&'a Wrapping<i128>> for Wrapping<i128>

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

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

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

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

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

impl DivRem for Wrapping<isize>

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

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

impl<'a> DivRem<Wrapping<isize>> for &'a Wrapping<isize>

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

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

impl<'a> DivRem<&'a Wrapping<isize>> for Wrapping<isize>

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

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

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

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

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

impl DivRem for Wrapping<u8>

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

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

impl<'a> DivRem<Wrapping<u8>> for &'a Wrapping<u8>

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

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

impl<'a> DivRem<&'a Wrapping<u8>> for Wrapping<u8>

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

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

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

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

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

impl DivRem for Wrapping<u16>

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

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

impl<'a> DivRem<Wrapping<u16>> for &'a Wrapping<u16>

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

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

impl<'a> DivRem<&'a Wrapping<u16>> for Wrapping<u16>

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

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

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

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

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

impl DivRem for Wrapping<u32>

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

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

impl<'a> DivRem<Wrapping<u32>> for &'a Wrapping<u32>

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

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

impl<'a> DivRem<&'a Wrapping<u32>> for Wrapping<u32>

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

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

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

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

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

impl DivRem for Wrapping<u64>

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

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

impl<'a> DivRem<Wrapping<u64>> for &'a Wrapping<u64>

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

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

impl<'a> DivRem<&'a Wrapping<u64>> for Wrapping<u64>

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

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

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

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

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

impl DivRem for Wrapping<u128>

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

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

impl<'a> DivRem<Wrapping<u128>> for &'a Wrapping<u128>

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

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

impl<'a> DivRem<&'a Wrapping<u128>> for Wrapping<u128>

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

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

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

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

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

impl DivRem for Wrapping<usize>

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

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

impl<'a> DivRem<Wrapping<usize>> for &'a Wrapping<usize>

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

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

impl<'a> DivRem<&'a Wrapping<usize>> for Wrapping<usize>

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

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

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

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

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

Implementors

• impl DivRem for i8 type Output = (Self::Output, Self::Output);

• impl<'a> DivRem<i8> for &'a i8 type Output = <i8 as DivRem<i8>>::Output;

• impl<'a> DivRem<&'a i8> for i8 type Output = <i8 as DivRem<i8>>::Output;

• impl<'a, 'b> DivRem<&'a i8> for &'b i8 type Output = <i8 as DivRem<i8>>::Output;

• impl DivRem for i16 type Output = (Self::Output, Self::Output);

• impl<'a> DivRem<i16> for &'a i16 type Output = <i16 as DivRem<i16>>::Output;

• impl<'a> DivRem<&'a i16> for i16 type Output = <i16 as DivRem<i16>>::Output;

• impl<'a, 'b> DivRem<&'a i16> for &'b i16 type Output = <i16 as DivRem<i16>>::Output;

• impl DivRem for i32 type Output = (Self::Output, Self::Output);

• impl<'a> DivRem<i32> for &'a i32 type Output = <i32 as DivRem<i32>>::Output;

• impl<'a> DivRem<&'a i32> for i32 type Output = <i32 as DivRem<i32>>::Output;

• impl<'a, 'b> DivRem<&'a i32> for &'b i32 type Output = <i32 as DivRem<i32>>::Output;

• impl DivRem for i64 type Output = (Self::Output, Self::Output);

• impl<'a> DivRem<i64> for &'a i64 type Output = <i64 as DivRem<i64>>::Output;

• impl<'a> DivRem<&'a i64> for i64 type Output = <i64 as DivRem<i64>>::Output;

• impl<'a, 'b> DivRem<&'a i64> for &'b i64 type Output = <i64 as DivRem<i64>>::Output;

• impl DivRem for i128 type Output = (Self::Output, Self::Output);

• impl<'a> DivRem<i128> for &'a i128 type Output = <i128 as DivRem<i128>>::Output;

• impl<'a> DivRem<&'a i128> for i128 type Output = <i128 as DivRem<i128>>::Output;

• impl<'a, 'b> DivRem<&'a i128> for &'b i128 type Output = <i128 as DivRem<i128>>::Output;

• impl DivRem for isize type Output = (Self::Output, Self::Output);

• impl<'a> DivRem<isize> for &'a isize type Output = <isize as DivRem<isize>>::Output;

• impl<'a> DivRem<&'a isize> for isize type Output = <isize as DivRem<isize>>::Output;

• impl<'a, 'b> DivRem<&'a isize> for &'b isize type Output = <isize as DivRem<isize>>::Output;

• impl DivRem for u8 type Output = (Self::Output, Self::Output);

• impl<'a> DivRem<u8> for &'a u8 type Output = <u8 as DivRem<u8>>::Output;

• impl<'a> DivRem<&'a u8> for u8 type Output = <u8 as DivRem<u8>>::Output;

• impl<'a, 'b> DivRem<&'a u8> for &'b u8 type Output = <u8 as DivRem<u8>>::Output;

• impl DivRem for u16 type Output = (Self::Output, Self::Output);

• impl<'a> DivRem<u16> for &'a u16 type Output = <u16 as DivRem<u16>>::Output;

• impl<'a> DivRem<&'a u16> for u16 type Output = <u16 as DivRem<u16>>::Output;

• impl<'a, 'b> DivRem<&'a u16> for &'b u16 type Output = <u16 as DivRem<u16>>::Output;

• impl DivRem for u32 type Output = (Self::Output, Self::Output);

• impl<'a> DivRem<u32> for &'a u32 type Output = <u32 as DivRem<u32>>::Output;

• impl<'a> DivRem<&'a u32> for u32 type Output = <u32 as DivRem<u32>>::Output;

• impl<'a, 'b> DivRem<&'a u32> for &'b u32 type Output = <u32 as DivRem<u32>>::Output;

• impl DivRem for u64 type Output = (Self::Output, Self::Output);

• impl<'a> DivRem<u64> for &'a u64 type Output = <u64 as DivRem<u64>>::Output;

• impl<'a> DivRem<&'a u64> for u64 type Output = <u64 as DivRem<u64>>::Output;

• impl<'a, 'b> DivRem<&'a u64> for &'b u64 type Output = <u64 as DivRem<u64>>::Output;

• impl DivRem for u128 type Output = (Self::Output, Self::Output);

• impl<'a> DivRem<u128> for &'a u128 type Output = <u128 as DivRem<u128>>::Output;

• impl<'a> DivRem<&'a u128> for u128 type Output = <u128 as DivRem<u128>>::Output;

• impl<'a, 'b> DivRem<&'a u128> for &'b u128 type Output = <u128 as DivRem<u128>>::Output;

• impl DivRem for usize type Output = (Self::Output, Self::Output);

• impl<'a> DivRem<usize> for &'a usize type Output = <usize as DivRem<usize>>::Output;

• impl<'a> DivRem<&'a usize> for usize type Output = <usize as DivRem<usize>>::Output;

• impl<'a, 'b> DivRem<&'a usize> for &'b usize type Output = <usize as DivRem<usize>>::Output;