Trait arith_traits::IOverflowingOps

pub trait IOverflowingOps<T = Self>where
    Self: PartialOrd,{
    type Output;

    fn overflowing_abs(self) -> Self::Output;
    fn overflowing_add(self, rhs: T) -> Self::Output;
    fn overflowing_div(self, rhs: T) -> Self::Output;
    fn overflowing_div_euclid(self, rhs: T) -> Self::Output;
    fn overflowing_mul(self, rhs: T) -> Self::Output;
    fn overflowing_neg(self) -> Self::Output;
    fn overflowing_pow(self, rhs: u32) -> Self::Output;
    fn overflowing_rem(self, rhs: T) -> Self::Output;
    fn overflowing_rem_euclid(self, rhs: T) -> Self::Output;
    fn overflowing_shl(self, rhs: u32) -> Self::Output;
    fn overflowing_shr(self, rhs: u32) -> Self::Output;
    fn overflowing_sub(self, rhs: T) -> Self::Output;
}

Required Associated Types

type Output

Required Methods

fn overflowing_abs(self) -> Self::Output

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

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

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

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

fn overflowing_neg(self) -> Self::Output

fn overflowing_pow(self, rhs: u32) -> Self::Output

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

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

fn overflowing_shl(self, rhs: u32) -> Self::Output

fn overflowing_shr(self, rhs: u32) -> Self::Output

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

Implementations on Foreign Types

impl IOverflowingOps<i8> for i8

type Output = (i8, bool)

fn overflowing_add(self, rhs: i8) -> <Self as IOverflowingOps>::Output

fn overflowing_div(self, rhs: i8) -> <Self as IOverflowingOps>::Output

fn overflowing_div_euclid(self, rhs: i8) -> <Self as IOverflowingOps>::Output

fn overflowing_mul(self, rhs: i8) -> <Self as IOverflowingOps>::Output

fn overflowing_rem(self, rhs: i8) -> <Self as IOverflowingOps>::Output

fn overflowing_rem_euclid(self, rhs: i8) -> <Self as IOverflowingOps>::Output

fn overflowing_sub(self, rhs: i8) -> <Self as IOverflowingOps>::Output

fn overflowing_pow(self, rhs: u32) -> <Self as IOverflowingOps>::Output

fn overflowing_shl(self, rhs: u32) -> <Self as IOverflowingOps>::Output

fn overflowing_shr(self, rhs: u32) -> <Self as IOverflowingOps>::Output

fn overflowing_abs(self) -> Self::Output

fn overflowing_neg(self) -> Self::Output

impl IOverflowingOps<i16> for i16

type Output = (i16, bool)

fn overflowing_add(self, rhs: i16) -> <Self as IOverflowingOps>::Output

fn overflowing_div(self, rhs: i16) -> <Self as IOverflowingOps>::Output

fn overflowing_div_euclid(self, rhs: i16) -> <Self as IOverflowingOps>::Output

fn overflowing_mul(self, rhs: i16) -> <Self as IOverflowingOps>::Output

fn overflowing_rem(self, rhs: i16) -> <Self as IOverflowingOps>::Output

fn overflowing_rem_euclid(self, rhs: i16) -> <Self as IOverflowingOps>::Output

fn overflowing_sub(self, rhs: i16) -> <Self as IOverflowingOps>::Output

fn overflowing_pow(self, rhs: u32) -> <Self as IOverflowingOps>::Output

fn overflowing_shl(self, rhs: u32) -> <Self as IOverflowingOps>::Output

fn overflowing_shr(self, rhs: u32) -> <Self as IOverflowingOps>::Output

fn overflowing_abs(self) -> Self::Output

fn overflowing_neg(self) -> Self::Output

impl IOverflowingOps<i32> for i32

type Output = (i32, bool)

fn overflowing_add(self, rhs: i32) -> <Self as IOverflowingOps>::Output

fn overflowing_div(self, rhs: i32) -> <Self as IOverflowingOps>::Output

fn overflowing_div_euclid(self, rhs: i32) -> <Self as IOverflowingOps>::Output

fn overflowing_mul(self, rhs: i32) -> <Self as IOverflowingOps>::Output

fn overflowing_rem(self, rhs: i32) -> <Self as IOverflowingOps>::Output

fn overflowing_rem_euclid(self, rhs: i32) -> <Self as IOverflowingOps>::Output

fn overflowing_sub(self, rhs: i32) -> <Self as IOverflowingOps>::Output

fn overflowing_pow(self, rhs: u32) -> <Self as IOverflowingOps>::Output

fn overflowing_shl(self, rhs: u32) -> <Self as IOverflowingOps>::Output

fn overflowing_shr(self, rhs: u32) -> <Self as IOverflowingOps>::Output

fn overflowing_abs(self) -> Self::Output

fn overflowing_neg(self) -> Self::Output

impl IOverflowingOps<i64> for i64

type Output = (i64, bool)

fn overflowing_add(self, rhs: i64) -> <Self as IOverflowingOps>::Output

fn overflowing_div(self, rhs: i64) -> <Self as IOverflowingOps>::Output

fn overflowing_div_euclid(self, rhs: i64) -> <Self as IOverflowingOps>::Output

fn overflowing_mul(self, rhs: i64) -> <Self as IOverflowingOps>::Output

fn overflowing_rem(self, rhs: i64) -> <Self as IOverflowingOps>::Output

fn overflowing_rem_euclid(self, rhs: i64) -> <Self as IOverflowingOps>::Output

fn overflowing_sub(self, rhs: i64) -> <Self as IOverflowingOps>::Output

fn overflowing_pow(self, rhs: u32) -> <Self as IOverflowingOps>::Output

fn overflowing_shl(self, rhs: u32) -> <Self as IOverflowingOps>::Output

fn overflowing_shr(self, rhs: u32) -> <Self as IOverflowingOps>::Output

fn overflowing_abs(self) -> Self::Output

fn overflowing_neg(self) -> Self::Output

impl IOverflowingOps<i128> for i128

type Output = (i128, bool)

fn overflowing_add(self, rhs: i128) -> <Self as IOverflowingOps>::Output

fn overflowing_div(self, rhs: i128) -> <Self as IOverflowingOps>::Output

fn overflowing_div_euclid(self, rhs: i128) -> <Self as IOverflowingOps>::Output

fn overflowing_mul(self, rhs: i128) -> <Self as IOverflowingOps>::Output

fn overflowing_rem(self, rhs: i128) -> <Self as IOverflowingOps>::Output

fn overflowing_rem_euclid(self, rhs: i128) -> <Self as IOverflowingOps>::Output

fn overflowing_sub(self, rhs: i128) -> <Self as IOverflowingOps>::Output

fn overflowing_pow(self, rhs: u32) -> <Self as IOverflowingOps>::Output

fn overflowing_shl(self, rhs: u32) -> <Self as IOverflowingOps>::Output

fn overflowing_shr(self, rhs: u32) -> <Self as IOverflowingOps>::Output

fn overflowing_abs(self) -> Self::Output

fn overflowing_neg(self) -> Self::Output

impl IOverflowingOps<isize> for isize

type Output = (isize, bool)

fn overflowing_add(self, rhs: isize) -> <Self as IOverflowingOps>::Output

fn overflowing_div(self, rhs: isize) -> <Self as IOverflowingOps>::Output

fn overflowing_div_euclid(self, rhs: isize) -> <Self as IOverflowingOps>::Output

fn overflowing_mul(self, rhs: isize) -> <Self as IOverflowingOps>::Output

fn overflowing_rem(self, rhs: isize) -> <Self as IOverflowingOps>::Output

fn overflowing_rem_euclid(self, rhs: isize) -> <Self as IOverflowingOps>::Output

fn overflowing_sub(self, rhs: isize) -> <Self as IOverflowingOps>::Output

fn overflowing_pow(self, rhs: u32) -> <Self as IOverflowingOps>::Output

fn overflowing_shl(self, rhs: u32) -> <Self as IOverflowingOps>::Output

fn overflowing_shr(self, rhs: u32) -> <Self as IOverflowingOps>::Output

fn overflowing_abs(self) -> Self::Output

fn overflowing_neg(self) -> Self::Output

impl IOverflowingOps<u8> for u8

type Output = (u8, bool)

fn overflowing_add(self, rhs: u8) -> <Self as IOverflowingOps>::Output

fn overflowing_div(self, rhs: u8) -> <Self as IOverflowingOps>::Output

fn overflowing_div_euclid(self, rhs: u8) -> <Self as IOverflowingOps>::Output

fn overflowing_mul(self, rhs: u8) -> <Self as IOverflowingOps>::Output

fn overflowing_rem(self, rhs: u8) -> <Self as IOverflowingOps>::Output

fn overflowing_rem_euclid(self, rhs: u8) -> <Self as IOverflowingOps>::Output

fn overflowing_sub(self, rhs: u8) -> <Self as IOverflowingOps>::Output

fn overflowing_pow(self, rhs: u32) -> <Self as IOverflowingOps>::Output

fn overflowing_shl(self, rhs: u32) -> <Self as IOverflowingOps>::Output

fn overflowing_shr(self, rhs: u32) -> <Self as IOverflowingOps>::Output

fn overflowing_abs(self) -> Self::Output

fn overflowing_neg(self) -> Self::Output

impl IOverflowingOps<u16> for u16

type Output = (u16, bool)

fn overflowing_add(self, rhs: u16) -> <Self as IOverflowingOps>::Output

fn overflowing_div(self, rhs: u16) -> <Self as IOverflowingOps>::Output

fn overflowing_div_euclid(self, rhs: u16) -> <Self as IOverflowingOps>::Output

fn overflowing_mul(self, rhs: u16) -> <Self as IOverflowingOps>::Output

fn overflowing_rem(self, rhs: u16) -> <Self as IOverflowingOps>::Output

fn overflowing_rem_euclid(self, rhs: u16) -> <Self as IOverflowingOps>::Output

fn overflowing_sub(self, rhs: u16) -> <Self as IOverflowingOps>::Output

fn overflowing_pow(self, rhs: u32) -> <Self as IOverflowingOps>::Output

fn overflowing_shl(self, rhs: u32) -> <Self as IOverflowingOps>::Output

fn overflowing_shr(self, rhs: u32) -> <Self as IOverflowingOps>::Output

fn overflowing_abs(self) -> Self::Output

fn overflowing_neg(self) -> Self::Output

impl IOverflowingOps<u32> for u32

type Output = (u32, bool)

fn overflowing_add(self, rhs: u32) -> <Self as IOverflowingOps>::Output

fn overflowing_div(self, rhs: u32) -> <Self as IOverflowingOps>::Output

fn overflowing_div_euclid(self, rhs: u32) -> <Self as IOverflowingOps>::Output

fn overflowing_mul(self, rhs: u32) -> <Self as IOverflowingOps>::Output

fn overflowing_rem(self, rhs: u32) -> <Self as IOverflowingOps>::Output

fn overflowing_rem_euclid(self, rhs: u32) -> <Self as IOverflowingOps>::Output

fn overflowing_sub(self, rhs: u32) -> <Self as IOverflowingOps>::Output

fn overflowing_pow(self, rhs: u32) -> <Self as IOverflowingOps>::Output

fn overflowing_shl(self, rhs: u32) -> <Self as IOverflowingOps>::Output

fn overflowing_shr(self, rhs: u32) -> <Self as IOverflowingOps>::Output

fn overflowing_abs(self) -> Self::Output

fn overflowing_neg(self) -> Self::Output

impl IOverflowingOps<u64> for u64

type Output = (u64, bool)

fn overflowing_add(self, rhs: u64) -> <Self as IOverflowingOps>::Output

fn overflowing_div(self, rhs: u64) -> <Self as IOverflowingOps>::Output

fn overflowing_div_euclid(self, rhs: u64) -> <Self as IOverflowingOps>::Output

fn overflowing_mul(self, rhs: u64) -> <Self as IOverflowingOps>::Output

fn overflowing_rem(self, rhs: u64) -> <Self as IOverflowingOps>::Output

fn overflowing_rem_euclid(self, rhs: u64) -> <Self as IOverflowingOps>::Output

fn overflowing_sub(self, rhs: u64) -> <Self as IOverflowingOps>::Output

fn overflowing_pow(self, rhs: u32) -> <Self as IOverflowingOps>::Output

fn overflowing_shl(self, rhs: u32) -> <Self as IOverflowingOps>::Output

fn overflowing_shr(self, rhs: u32) -> <Self as IOverflowingOps>::Output

fn overflowing_abs(self) -> Self::Output

fn overflowing_neg(self) -> Self::Output

impl IOverflowingOps<u128> for u128

type Output = (u128, bool)

fn overflowing_add(self, rhs: u128) -> <Self as IOverflowingOps>::Output

fn overflowing_div(self, rhs: u128) -> <Self as IOverflowingOps>::Output

fn overflowing_div_euclid(self, rhs: u128) -> <Self as IOverflowingOps>::Output

fn overflowing_mul(self, rhs: u128) -> <Self as IOverflowingOps>::Output

fn overflowing_rem(self, rhs: u128) -> <Self as IOverflowingOps>::Output

fn overflowing_rem_euclid(self, rhs: u128) -> <Self as IOverflowingOps>::Output

fn overflowing_sub(self, rhs: u128) -> <Self as IOverflowingOps>::Output

fn overflowing_pow(self, rhs: u32) -> <Self as IOverflowingOps>::Output

fn overflowing_shl(self, rhs: u32) -> <Self as IOverflowingOps>::Output

fn overflowing_shr(self, rhs: u32) -> <Self as IOverflowingOps>::Output

fn overflowing_abs(self) -> Self::Output

fn overflowing_neg(self) -> Self::Output

impl IOverflowingOps<usize> for usize

type Output = (usize, bool)

fn overflowing_add(self, rhs: usize) -> <Self as IOverflowingOps>::Output

fn overflowing_div(self, rhs: usize) -> <Self as IOverflowingOps>::Output

fn overflowing_div_euclid(self, rhs: usize) -> <Self as IOverflowingOps>::Output

fn overflowing_mul(self, rhs: usize) -> <Self as IOverflowingOps>::Output

fn overflowing_rem(self, rhs: usize) -> <Self as IOverflowingOps>::Output

fn overflowing_rem_euclid(self, rhs: usize) -> <Self as IOverflowingOps>::Output

fn overflowing_sub(self, rhs: usize) -> <Self as IOverflowingOps>::Output

fn overflowing_pow(self, rhs: u32) -> <Self as IOverflowingOps>::Output

fn overflowing_shl(self, rhs: u32) -> <Self as IOverflowingOps>::Output

fn overflowing_shr(self, rhs: u32) -> <Self as IOverflowingOps>::Output

fn overflowing_abs(self) -> Self::Output

fn overflowing_neg(self) -> Self::Output

Implementors