Struct Bound 

#[non_exhaustive]
pub struct Bound<T> {
    pub value: ValueWrapper<T>,
    pub interval: Interval,
}

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

value: ValueWrapper<T>

interval: Interval

Implementations

impl<T> Bound<T>

pub fn new(value: ValueWrapper<T>, interval: Interval) -> Self

Trait Implementations

impl<'a, 'b> Add<&'a Bound<f32>> for &'b Bound<f32>

type Output = Result<Bound<<f32 as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Bound<f32>) -> Self::Output

Performs the + operation.

impl<'a, 'b> Add<&'b Bound<f32>> for &'a f32

type Output = Result<Bound<<&'a f32 as Add<&'b f32>>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: &'b Bound<f32>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Bound<f32>> for Bound<f32>

type Output = Result<Bound<<f32 as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Bound<f32>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Bound<f32>> for f32

type Output = Result<Bound<<f32 as Add<&'a f32>>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Bound<f32>) -> Self::Output

Performs the + operation.

impl<'a, 'b> Add<&'a Bound<f64>> for &'b Bound<f64>

type Output = Result<Bound<<f64 as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Bound<f64>) -> Self::Output

Performs the + operation.

impl<'a, 'b> Add<&'b Bound<f64>> for &'a f64

type Output = Result<Bound<<&'a f64 as Add<&'b f64>>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: &'b Bound<f64>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Bound<f64>> for Bound<f64>

type Output = Result<Bound<<f64 as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Bound<f64>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Bound<f64>> for f64

type Output = Result<Bound<<f64 as Add<&'a f64>>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Bound<f64>) -> Self::Output

Performs the + operation.

impl<'a, 'b> Add<&'a Bound<i128>> for &'b Bound<i128>

type Output = Result<Bound<<i128 as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Bound<i128>) -> Self::Output

Performs the + operation.

impl<'a, 'b> Add<&'b Bound<i128>> for &'a i128

type Output = Result<Bound<<&'a i128 as Add<&'b i128>>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: &'b Bound<i128>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Bound<i128>> for Bound<i128>

type Output = Result<Bound<<i128 as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Bound<i128>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Bound<i128>> for i128

type Output = Result<Bound<<i128 as Add<&'a i128>>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Bound<i128>) -> Self::Output

Performs the + operation.

impl<'a, 'b> Add<&'a Bound<i16>> for &'b Bound<i16>

type Output = Result<Bound<<i16 as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Bound<i16>) -> Self::Output

Performs the + operation.

impl<'a, 'b> Add<&'b Bound<i16>> for &'a i16

type Output = Result<Bound<<&'a i16 as Add<&'b i16>>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: &'b Bound<i16>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Bound<i16>> for Bound<i16>

type Output = Result<Bound<<i16 as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Bound<i16>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Bound<i16>> for i16

type Output = Result<Bound<<i16 as Add<&'a i16>>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Bound<i16>) -> Self::Output

Performs the + operation.

impl<'a, 'b> Add<&'a Bound<i32>> for &'b Bound<i32>

type Output = Result<Bound<<i32 as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Bound<i32>) -> Self::Output

Performs the + operation.

impl<'a, 'b> Add<&'b Bound<i32>> for &'a i32

type Output = Result<Bound<<&'a i32 as Add<&'b i32>>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: &'b Bound<i32>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Bound<i32>> for Bound<i32>

type Output = Result<Bound<<i32 as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Bound<i32>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Bound<i32>> for i32

type Output = Result<Bound<<i32 as Add<&'a i32>>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Bound<i32>) -> Self::Output

Performs the + operation.

impl<'a, 'b> Add<&'a Bound<i64>> for &'b Bound<i64>

type Output = Result<Bound<<i64 as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Bound<i64>) -> Self::Output

Performs the + operation.

impl<'a, 'b> Add<&'b Bound<i64>> for &'a i64

type Output = Result<Bound<<&'a i64 as Add<&'b i64>>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: &'b Bound<i64>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Bound<i64>> for Bound<i64>

type Output = Result<Bound<<i64 as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Bound<i64>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Bound<i64>> for i64

type Output = Result<Bound<<i64 as Add<&'a i64>>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Bound<i64>) -> Self::Output

Performs the + operation.

impl<'a, 'b> Add<&'a Bound<i8>> for &'b Bound<i8>

type Output = Result<Bound<<i8 as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Bound<i8>) -> Self::Output

Performs the + operation.

impl<'a, 'b> Add<&'b Bound<i8>> for &'a i8

type Output = Result<Bound<<&'a i8 as Add<&'b i8>>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: &'b Bound<i8>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Bound<i8>> for Bound<i8>

type Output = Result<Bound<<i8 as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Bound<i8>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Bound<i8>> for i8

type Output = Result<Bound<<i8 as Add<&'a i8>>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Bound<i8>) -> Self::Output

Performs the + operation.

impl<'a, 'b> Add<&'a Bound<isize>> for &'b Bound<isize>

type Output = Result<Bound<<isize as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Bound<isize>) -> Self::Output

Performs the + operation.

impl<'a, 'b> Add<&'b Bound<isize>> for &'a isize

type Output = Result<Bound<<&'a isize as Add<&'b isize>>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: &'b Bound<isize>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Bound<isize>> for Bound<isize>

type Output = Result<Bound<<isize as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Bound<isize>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Bound<isize>> for isize

type Output = Result<Bound<<isize as Add<&'a isize>>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Bound<isize>) -> Self::Output

Performs the + operation.

impl<'a, 'b> Add<&'a Bound<u128>> for &'b Bound<u128>

type Output = Result<Bound<<u128 as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Bound<u128>) -> Self::Output

Performs the + operation.

impl<'a, 'b> Add<&'b Bound<u128>> for &'a u128

type Output = Result<Bound<<&'a u128 as Add<&'b u128>>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: &'b Bound<u128>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Bound<u128>> for Bound<u128>

type Output = Result<Bound<<u128 as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Bound<u128>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Bound<u128>> for u128

type Output = Result<Bound<<u128 as Add<&'a u128>>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Bound<u128>) -> Self::Output

Performs the + operation.

impl<'a, 'b> Add<&'a Bound<u16>> for &'b Bound<u16>

type Output = Result<Bound<<u16 as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Bound<u16>) -> Self::Output

Performs the + operation.

impl<'a, 'b> Add<&'b Bound<u16>> for &'a u16

type Output = Result<Bound<<&'a u16 as Add<&'b u16>>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: &'b Bound<u16>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Bound<u16>> for Bound<u16>

type Output = Result<Bound<<u16 as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Bound<u16>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Bound<u16>> for u16

type Output = Result<Bound<<u16 as Add<&'a u16>>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Bound<u16>) -> Self::Output

Performs the + operation.

impl<'a, 'b> Add<&'a Bound<u32>> for &'b Bound<u32>

type Output = Result<Bound<<u32 as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Bound<u32>) -> Self::Output

Performs the + operation.

impl<'a, 'b> Add<&'b Bound<u32>> for &'a u32

type Output = Result<Bound<<&'a u32 as Add<&'b u32>>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: &'b Bound<u32>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Bound<u32>> for Bound<u32>

type Output = Result<Bound<<u32 as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Bound<u32>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Bound<u32>> for u32

type Output = Result<Bound<<u32 as Add<&'a u32>>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Bound<u32>) -> Self::Output

Performs the + operation.

impl<'a, 'b> Add<&'a Bound<u64>> for &'b Bound<u64>

type Output = Result<Bound<<u64 as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Bound<u64>) -> Self::Output

Performs the + operation.

impl<'a, 'b> Add<&'b Bound<u64>> for &'a u64

type Output = Result<Bound<<&'a u64 as Add<&'b u64>>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: &'b Bound<u64>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Bound<u64>> for Bound<u64>

type Output = Result<Bound<<u64 as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Bound<u64>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Bound<u64>> for u64

type Output = Result<Bound<<u64 as Add<&'a u64>>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Bound<u64>) -> Self::Output

Performs the + operation.

impl<'a, 'b> Add<&'a Bound<u8>> for &'b Bound<u8>

type Output = Result<Bound<<u8 as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Bound<u8>) -> Self::Output

Performs the + operation.

impl<'a, 'b> Add<&'b Bound<u8>> for &'a u8

type Output = Result<Bound<<&'a u8 as Add<&'b u8>>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: &'b Bound<u8>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Bound<u8>> for Bound<u8>

type Output = Result<Bound<<u8 as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Bound<u8>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Bound<u8>> for u8

type Output = Result<Bound<<u8 as Add<&'a u8>>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Bound<u8>) -> Self::Output

Performs the + operation.

impl<'a, 'b> Add<&'a Bound<usize>> for &'b Bound<usize>

type Output = Result<Bound<<usize as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Bound<usize>) -> Self::Output

Performs the + operation.

impl<'a, 'b> Add<&'b Bound<usize>> for &'a usize

type Output = Result<Bound<<&'a usize as Add<&'b usize>>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: &'b Bound<usize>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Bound<usize>> for Bound<usize>

type Output = Result<Bound<<usize as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Bound<usize>) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Bound<usize>> for usize

type Output = Result<Bound<<usize as Add<&'a usize>>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Bound<usize>) -> Self::Output

Performs the + operation.

impl<'a, 'b> Add<&'a Duration> for &'b Bound<Duration>

type Output = Result<Bound<<Duration as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Duration) -> Self::Output

Performs the + operation.

impl<'a, 'b> Add<&'a Duration> for &'b Bound<Instant>

type Output = Result<Bound<<Instant as Add<Duration>>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Duration) -> Self::Output

Performs the + operation.

impl<'a, 'b> Add<&'a Duration> for &'b Bound<NaiveDateTime>

type Output = Result<Bound<<NaiveDateTime as Add<Duration>>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Duration) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Duration> for Bound<Duration>

type Output = Result<Bound<<Duration as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Duration) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Duration> for Bound<Instant>

type Output = Result<Bound<<Instant as Add<Duration>>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Duration) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a Duration> for Bound<NaiveDateTime>

type Output = Result<Bound<<NaiveDateTime as Add<Duration>>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Duration) -> Self::Output

Performs the + operation.

impl<'a, 'b> Add<&'a f32> for &'b Bound<f32>

type Output = Result<Bound<<f32 as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: &'a f32) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a f32> for Bound<f32>

type Output = Result<Bound<<f32 as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: &'a f32) -> Self::Output

Performs the + operation.

impl<'a, 'b> Add<&'a f64> for &'b Bound<f64>

type Output = Result<Bound<<f64 as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: &'a f64) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a f64> for Bound<f64>

type Output = Result<Bound<<f64 as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: &'a f64) -> Self::Output

Performs the + operation.

impl<'a, 'b> Add<&'a i128> for &'b Bound<i128>

type Output = Result<Bound<<i128 as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: &'a i128) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a i128> for Bound<i128>

type Output = Result<Bound<<i128 as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: &'a i128) -> Self::Output

Performs the + operation.

impl<'a, 'b> Add<&'a i16> for &'b Bound<i16>

type Output = Result<Bound<<i16 as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: &'a i16) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a i16> for Bound<i16>

type Output = Result<Bound<<i16 as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: &'a i16) -> Self::Output

Performs the + operation.

impl<'a, 'b> Add<&'a i32> for &'b Bound<i32>

type Output = Result<Bound<<i32 as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: &'a i32) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a i32> for Bound<i32>

type Output = Result<Bound<<i32 as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: &'a i32) -> Self::Output

Performs the + operation.

impl<'a, 'b> Add<&'a i64> for &'b Bound<i64>

type Output = Result<Bound<<i64 as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: &'a i64) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a i64> for Bound<i64>

type Output = Result<Bound<<i64 as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: &'a i64) -> Self::Output

Performs the + operation.

impl<'a, 'b> Add<&'a i8> for &'b Bound<i8>

type Output = Result<Bound<<i8 as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: &'a i8) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a i8> for Bound<i8>

type Output = Result<Bound<<i8 as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: &'a i8) -> Self::Output

Performs the + operation.

impl<'a, 'b> Add<&'a isize> for &'b Bound<isize>

type Output = Result<Bound<<isize as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: &'a isize) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a isize> for Bound<isize>

type Output = Result<Bound<<isize as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: &'a isize) -> Self::Output

Performs the + operation.

impl<'a, 'b> Add<&'a u128> for &'b Bound<u128>

type Output = Result<Bound<<u128 as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: &'a u128) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a u128> for Bound<u128>

type Output = Result<Bound<<u128 as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: &'a u128) -> Self::Output

Performs the + operation.

impl<'a, 'b> Add<&'a u16> for &'b Bound<u16>

type Output = Result<Bound<<u16 as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: &'a u16) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a u16> for Bound<u16>

type Output = Result<Bound<<u16 as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: &'a u16) -> Self::Output

Performs the + operation.

impl<'a, 'b> Add<&'a u32> for &'b Bound<u32>

type Output = Result<Bound<<u32 as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: &'a u32) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a u32> for Bound<u32>

type Output = Result<Bound<<u32 as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: &'a u32) -> Self::Output

Performs the + operation.

impl<'a, 'b> Add<&'a u64> for &'b Bound<u64>

type Output = Result<Bound<<u64 as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: &'a u64) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a u64> for Bound<u64>

type Output = Result<Bound<<u64 as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: &'a u64) -> Self::Output

Performs the + operation.

impl<'a, 'b> Add<&'a u8> for &'b Bound<u8>

type Output = Result<Bound<<u8 as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: &'a u8) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a u8> for Bound<u8>

type Output = Result<Bound<<u8 as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: &'a u8) -> Self::Output

Performs the + operation.

impl<'a, 'b> Add<&'a usize> for &'b Bound<usize>

type Output = Result<Bound<<usize as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: &'a usize) -> Self::Output

Performs the + operation.

impl<'a> Add<&'a usize> for Bound<usize>

type Output = Result<Bound<<usize as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: &'a usize) -> Self::Output

Performs the + operation.

impl<'a> Add<Bound<f32>> for &'a Bound<f32>

type Output = Result<Bound<<f32 as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: Bound<f32>) -> Self::Output

Performs the + operation.

impl<'a> Add<Bound<f32>> for &'a f32

type Output = Result<Bound<<&'a f32 as Add<f32>>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: Bound<f32>) -> Self::Output

Performs the + operation.

impl Add<Bound<f32>> for f32

type Output = Result<Bound<<f32 as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: Bound<f32>) -> Self::Output

Performs the + operation.

impl<'a> Add<Bound<f64>> for &'a Bound<f64>

type Output = Result<Bound<<f64 as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: Bound<f64>) -> Self::Output

Performs the + operation.

impl<'a> Add<Bound<f64>> for &'a f64

type Output = Result<Bound<<&'a f64 as Add<f64>>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: Bound<f64>) -> Self::Output

Performs the + operation.

impl Add<Bound<f64>> for f64

type Output = Result<Bound<<f64 as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: Bound<f64>) -> Self::Output

Performs the + operation.

impl<'a> Add<Bound<i128>> for &'a Bound<i128>

type Output = Result<Bound<<i128 as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: Bound<i128>) -> Self::Output

Performs the + operation.

impl<'a> Add<Bound<i128>> for &'a i128

type Output = Result<Bound<<&'a i128 as Add<i128>>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: Bound<i128>) -> Self::Output

Performs the + operation.

impl Add<Bound<i128>> for i128

type Output = Result<Bound<<i128 as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: Bound<i128>) -> Self::Output

Performs the + operation.

impl<'a> Add<Bound<i16>> for &'a Bound<i16>

type Output = Result<Bound<<i16 as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: Bound<i16>) -> Self::Output

Performs the + operation.

impl<'a> Add<Bound<i16>> for &'a i16

type Output = Result<Bound<<&'a i16 as Add<i16>>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: Bound<i16>) -> Self::Output

Performs the + operation.

impl Add<Bound<i16>> for i16

type Output = Result<Bound<<i16 as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: Bound<i16>) -> Self::Output

Performs the + operation.

impl<'a> Add<Bound<i32>> for &'a Bound<i32>

type Output = Result<Bound<<i32 as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: Bound<i32>) -> Self::Output

Performs the + operation.

impl<'a> Add<Bound<i32>> for &'a i32

type Output = Result<Bound<<&'a i32 as Add<i32>>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: Bound<i32>) -> Self::Output

Performs the + operation.

impl Add<Bound<i32>> for i32

type Output = Result<Bound<<i32 as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: Bound<i32>) -> Self::Output

Performs the + operation.

impl<'a> Add<Bound<i64>> for &'a Bound<i64>

type Output = Result<Bound<<i64 as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: Bound<i64>) -> Self::Output

Performs the + operation.

impl<'a> Add<Bound<i64>> for &'a i64

type Output = Result<Bound<<&'a i64 as Add<i64>>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: Bound<i64>) -> Self::Output

Performs the + operation.

impl Add<Bound<i64>> for i64

type Output = Result<Bound<<i64 as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: Bound<i64>) -> Self::Output

Performs the + operation.

impl<'a> Add<Bound<i8>> for &'a Bound<i8>

type Output = Result<Bound<<i8 as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: Bound<i8>) -> Self::Output

Performs the + operation.

impl<'a> Add<Bound<i8>> for &'a i8

type Output = Result<Bound<<&'a i8 as Add<i8>>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: Bound<i8>) -> Self::Output

Performs the + operation.

impl Add<Bound<i8>> for i8

type Output = Result<Bound<<i8 as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: Bound<i8>) -> Self::Output

Performs the + operation.

impl<'a> Add<Bound<isize>> for &'a Bound<isize>

type Output = Result<Bound<<isize as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: Bound<isize>) -> Self::Output

Performs the + operation.

impl<'a> Add<Bound<isize>> for &'a isize

type Output = Result<Bound<<&'a isize as Add<isize>>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: Bound<isize>) -> Self::Output

Performs the + operation.

impl Add<Bound<isize>> for isize

type Output = Result<Bound<<isize as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: Bound<isize>) -> Self::Output

Performs the + operation.

impl<'a> Add<Bound<u128>> for &'a Bound<u128>

type Output = Result<Bound<<u128 as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: Bound<u128>) -> Self::Output

Performs the + operation.

impl<'a> Add<Bound<u128>> for &'a u128

type Output = Result<Bound<<&'a u128 as Add<u128>>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: Bound<u128>) -> Self::Output

Performs the + operation.

impl Add<Bound<u128>> for u128

type Output = Result<Bound<<u128 as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: Bound<u128>) -> Self::Output

Performs the + operation.

impl<'a> Add<Bound<u16>> for &'a Bound<u16>

type Output = Result<Bound<<u16 as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: Bound<u16>) -> Self::Output

Performs the + operation.

impl<'a> Add<Bound<u16>> for &'a u16

type Output = Result<Bound<<&'a u16 as Add<u16>>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: Bound<u16>) -> Self::Output

Performs the + operation.

impl Add<Bound<u16>> for u16

type Output = Result<Bound<<u16 as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: Bound<u16>) -> Self::Output

Performs the + operation.

impl<'a> Add<Bound<u32>> for &'a Bound<u32>

type Output = Result<Bound<<u32 as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: Bound<u32>) -> Self::Output

Performs the + operation.

impl<'a> Add<Bound<u32>> for &'a u32

type Output = Result<Bound<<&'a u32 as Add<u32>>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: Bound<u32>) -> Self::Output

Performs the + operation.

impl Add<Bound<u32>> for u32

type Output = Result<Bound<<u32 as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: Bound<u32>) -> Self::Output

Performs the + operation.

impl<'a> Add<Bound<u64>> for &'a Bound<u64>

type Output = Result<Bound<<u64 as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: Bound<u64>) -> Self::Output

Performs the + operation.

impl<'a> Add<Bound<u64>> for &'a u64

type Output = Result<Bound<<&'a u64 as Add<u64>>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: Bound<u64>) -> Self::Output

Performs the + operation.

impl Add<Bound<u64>> for u64

type Output = Result<Bound<<u64 as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: Bound<u64>) -> Self::Output

Performs the + operation.

impl<'a> Add<Bound<u8>> for &'a Bound<u8>

type Output = Result<Bound<<u8 as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: Bound<u8>) -> Self::Output

Performs the + operation.

impl<'a> Add<Bound<u8>> for &'a u8

type Output = Result<Bound<<&'a u8 as Add<u8>>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: Bound<u8>) -> Self::Output

Performs the + operation.

impl Add<Bound<u8>> for u8

type Output = Result<Bound<<u8 as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: Bound<u8>) -> Self::Output

Performs the + operation.

impl<'a> Add<Bound<usize>> for &'a Bound<usize>

type Output = Result<Bound<<usize as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: Bound<usize>) -> Self::Output

Performs the + operation.

impl<'a> Add<Bound<usize>> for &'a usize

type Output = Result<Bound<<&'a usize as Add<usize>>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: Bound<usize>) -> Self::Output

Performs the + operation.

impl Add<Bound<usize>> for usize

type Output = Result<Bound<<usize as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: Bound<usize>) -> Self::Output

Performs the + operation.

impl<'a> Add<Duration> for &'a Bound<Duration>

type Output = Result<Bound<<Duration as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: Duration) -> Self::Output

Performs the + operation.

impl<'a> Add<Duration> for &'a Bound<Instant>

type Output = Result<Bound<<Instant as Add<Duration>>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: Duration) -> Self::Output

Performs the + operation.

impl<'a> Add<Duration> for &'a Bound<NaiveDateTime>

type Output = Result<Bound<<NaiveDateTime as Add<Duration>>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: Duration) -> Self::Output

Performs the + operation.

impl Add<Duration> for Bound<Duration>

type Output = Result<Bound<<Duration as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: Duration) -> Self::Output

Performs the + operation.

impl Add<Duration> for Bound<Instant>

type Output = Result<Bound<<Instant as Add<Duration>>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: Duration) -> Self::Output

Performs the + operation.

impl Add<Duration> for Bound<NaiveDateTime>

type Output = Result<Bound<<NaiveDateTime as Add<Duration>>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: Duration) -> Self::Output

Performs the + operation.

impl<'a> Add<f32> for &'a Bound<f32>

type Output = Result<Bound<<f32 as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: f32) -> Self::Output

Performs the + operation.

impl Add<f32> for Bound<f32>

type Output = Result<Bound<<f32 as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: f32) -> Self::Output

Performs the + operation.

impl<'a> Add<f64> for &'a Bound<f64>

type Output = Result<Bound<<f64 as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: f64) -> Self::Output

Performs the + operation.

impl Add<f64> for Bound<f64>

type Output = Result<Bound<<f64 as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: f64) -> Self::Output

Performs the + operation.

impl<'a> Add<i128> for &'a Bound<i128>

type Output = Result<Bound<<i128 as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: i128) -> Self::Output

Performs the + operation.

impl Add<i128> for Bound<i128>

type Output = Result<Bound<<i128 as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: i128) -> Self::Output

Performs the + operation.

impl<'a> Add<i16> for &'a Bound<i16>

type Output = Result<Bound<<i16 as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: i16) -> Self::Output

Performs the + operation.

impl Add<i16> for Bound<i16>

type Output = Result<Bound<<i16 as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: i16) -> Self::Output

Performs the + operation.

impl<'a> Add<i32> for &'a Bound<i32>

type Output = Result<Bound<<i32 as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: i32) -> Self::Output

Performs the + operation.

impl Add<i32> for Bound<i32>

type Output = Result<Bound<<i32 as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: i32) -> Self::Output

Performs the + operation.

impl<'a> Add<i64> for &'a Bound<i64>

type Output = Result<Bound<<i64 as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: i64) -> Self::Output

Performs the + operation.

impl Add<i64> for Bound<i64>

type Output = Result<Bound<<i64 as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: i64) -> Self::Output

Performs the + operation.

impl<'a> Add<i8> for &'a Bound<i8>

type Output = Result<Bound<<i8 as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: i8) -> Self::Output

Performs the + operation.

impl Add<i8> for Bound<i8>

type Output = Result<Bound<<i8 as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: i8) -> Self::Output

Performs the + operation.

impl<'a> Add<isize> for &'a Bound<isize>

type Output = Result<Bound<<isize as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: isize) -> Self::Output

Performs the + operation.

impl Add<isize> for Bound<isize>

type Output = Result<Bound<<isize as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: isize) -> Self::Output

Performs the + operation.

impl<'a> Add<u128> for &'a Bound<u128>

type Output = Result<Bound<<u128 as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: u128) -> Self::Output

Performs the + operation.

impl Add<u128> for Bound<u128>

type Output = Result<Bound<<u128 as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: u128) -> Self::Output

Performs the + operation.

impl<'a> Add<u16> for &'a Bound<u16>

type Output = Result<Bound<<u16 as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: u16) -> Self::Output

Performs the + operation.

impl Add<u16> for Bound<u16>

type Output = Result<Bound<<u16 as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: u16) -> Self::Output

Performs the + operation.

impl<'a> Add<u32> for &'a Bound<u32>

type Output = Result<Bound<<u32 as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<u32> for Bound<u32>

type Output = Result<Bound<<u32 as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'a> Add<u64> for &'a Bound<u64>

type Output = Result<Bound<<u64 as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: u64) -> Self::Output

Performs the + operation.

impl Add<u64> for Bound<u64>

type Output = Result<Bound<<u64 as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: u64) -> Self::Output

Performs the + operation.

impl<'a> Add<u8> for &'a Bound<u8>

type Output = Result<Bound<<u8 as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: u8) -> Self::Output

Performs the + operation.

impl Add<u8> for Bound<u8>

type Output = Result<Bound<<u8 as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: u8) -> Self::Output

Performs the + operation.

impl<'a> Add<usize> for &'a Bound<usize>

type Output = Result<Bound<<usize as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: usize) -> Self::Output

Performs the + operation.

impl Add<usize> for Bound<usize>

type Output = Result<Bound<<usize as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: usize) -> Self::Output

Performs the + operation.

impl Add for Bound<f32>

type Output = Result<Bound<<f32 as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: Bound<f32>) -> Self::Output

Performs the + operation.

impl Add for Bound<f64>

type Output = Result<Bound<<f64 as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: Bound<f64>) -> Self::Output

Performs the + operation.

impl Add for Bound<i128>

type Output = Result<Bound<<i128 as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: Bound<i128>) -> Self::Output

Performs the + operation.

impl Add for Bound<i16>

type Output = Result<Bound<<i16 as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: Bound<i16>) -> Self::Output

Performs the + operation.

impl Add for Bound<i32>

type Output = Result<Bound<<i32 as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: Bound<i32>) -> Self::Output

Performs the + operation.

impl Add for Bound<i64>

type Output = Result<Bound<<i64 as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: Bound<i64>) -> Self::Output

Performs the + operation.

impl Add for Bound<i8>

type Output = Result<Bound<<i8 as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: Bound<i8>) -> Self::Output

Performs the + operation.

impl Add for Bound<isize>

type Output = Result<Bound<<isize as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: Bound<isize>) -> Self::Output

Performs the + operation.

impl Add for Bound<u128>

type Output = Result<Bound<<u128 as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: Bound<u128>) -> Self::Output

Performs the + operation.

impl Add for Bound<u16>

type Output = Result<Bound<<u16 as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: Bound<u16>) -> Self::Output

Performs the + operation.

impl Add for Bound<u32>

type Output = Result<Bound<<u32 as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: Bound<u32>) -> Self::Output

Performs the + operation.

impl Add for Bound<u64>

type Output = Result<Bound<<u64 as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: Bound<u64>) -> Self::Output

Performs the + operation.

impl Add for Bound<u8>

type Output = Result<Bound<<u8 as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: Bound<u8>) -> Self::Output

Performs the + operation.

impl Add for Bound<usize>

type Output = Result<Bound<<usize as Add>::Output>, IllegalArgumentError>

The resulting type after applying the + operator.

fn add(self, rhs: Bound<usize>) -> Self::Output

Performs the + operation.

impl<T: Clone> Clone for Bound<T>

fn clone(&self) -> Bound<T>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a, 'b> Div<&'a Bound<f32>> for &'b Bound<f32>

type Output = Result<Bound<<f32 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Bound<f32>) -> Self::Output

Performs the / operation.

impl<'a, 'b> Div<&'b Bound<f32>> for &'a f32

type Output = Result<Bound<<f32 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: &'b Bound<f32>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Bound<f32>> for Bound<f32>

type Output = Result<Bound<<f32 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Bound<f32>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Bound<f32>> for f32

type Output = Result<Bound<<f32 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Bound<f32>) -> Self::Output

Performs the / operation.

impl<'a, 'b> Div<&'a Bound<f64>> for &'b Bound<f64>

type Output = Result<Bound<<f64 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Bound<f64>) -> Self::Output

Performs the / operation.

impl<'a, 'b> Div<&'b Bound<f64>> for &'a f64

type Output = Result<Bound<<f64 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: &'b Bound<f64>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Bound<f64>> for Bound<f64>

type Output = Result<Bound<<f64 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Bound<f64>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Bound<f64>> for f64

type Output = Result<Bound<<f64 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Bound<f64>) -> Self::Output

Performs the / operation.

impl<'a, 'b> Div<&'a Bound<i128>> for &'b Bound<i128>

type Output = Result<Bound<<i128 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Bound<i128>) -> Self::Output

Performs the / operation.

impl<'a, 'b> Div<&'b Bound<i128>> for &'a i128

type Output = Result<Bound<<i128 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: &'b Bound<i128>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Bound<i128>> for Bound<i128>

type Output = Result<Bound<<i128 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Bound<i128>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Bound<i128>> for i128

type Output = Result<Bound<<i128 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Bound<i128>) -> Self::Output

Performs the / operation.

impl<'a, 'b> Div<&'a Bound<i16>> for &'b Bound<i16>

type Output = Result<Bound<<i16 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Bound<i16>) -> Self::Output

Performs the / operation.

impl<'a, 'b> Div<&'b Bound<i16>> for &'a i16

type Output = Result<Bound<<i16 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: &'b Bound<i16>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Bound<i16>> for Bound<i16>

type Output = Result<Bound<<i16 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Bound<i16>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Bound<i16>> for i16

type Output = Result<Bound<<i16 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Bound<i16>) -> Self::Output

Performs the / operation.

impl<'a, 'b> Div<&'a Bound<i32>> for &'b Bound<i32>

type Output = Result<Bound<<i32 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Bound<i32>) -> Self::Output

Performs the / operation.

impl<'a, 'b> Div<&'b Bound<i32>> for &'a i32

type Output = Result<Bound<<i32 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: &'b Bound<i32>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Bound<i32>> for Bound<i32>

type Output = Result<Bound<<i32 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Bound<i32>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Bound<i32>> for i32

type Output = Result<Bound<<i32 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Bound<i32>) -> Self::Output

Performs the / operation.

impl<'a, 'b> Div<&'a Bound<i64>> for &'b Bound<i64>

type Output = Result<Bound<<i64 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Bound<i64>) -> Self::Output

Performs the / operation.

impl<'a, 'b> Div<&'b Bound<i64>> for &'a i64

type Output = Result<Bound<<i64 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: &'b Bound<i64>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Bound<i64>> for Bound<i64>

type Output = Result<Bound<<i64 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Bound<i64>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Bound<i64>> for i64

type Output = Result<Bound<<i64 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Bound<i64>) -> Self::Output

Performs the / operation.

impl<'a, 'b> Div<&'a Bound<i8>> for &'b Bound<i8>

type Output = Result<Bound<<i8 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Bound<i8>) -> Self::Output

Performs the / operation.

impl<'a, 'b> Div<&'b Bound<i8>> for &'a i8

type Output = Result<Bound<<i8 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: &'b Bound<i8>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Bound<i8>> for Bound<i8>

type Output = Result<Bound<<i8 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Bound<i8>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Bound<i8>> for i8

type Output = Result<Bound<<i8 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Bound<i8>) -> Self::Output

Performs the / operation.

impl<'a, 'b> Div<&'a Bound<isize>> for &'b Bound<isize>

type Output = Result<Bound<<isize as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Bound<isize>) -> Self::Output

Performs the / operation.

impl<'a, 'b> Div<&'b Bound<isize>> for &'a isize

type Output = Result<Bound<<isize as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: &'b Bound<isize>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Bound<isize>> for Bound<isize>

type Output = Result<Bound<<isize as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Bound<isize>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Bound<isize>> for isize

type Output = Result<Bound<<isize as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Bound<isize>) -> Self::Output

Performs the / operation.

impl<'a, 'b> Div<&'a Bound<u128>> for &'b Bound<u128>

type Output = Result<Bound<<u128 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Bound<u128>) -> Self::Output

Performs the / operation.

impl<'a, 'b> Div<&'b Bound<u128>> for &'a u128

type Output = Result<Bound<<u128 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: &'b Bound<u128>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Bound<u128>> for Bound<u128>

type Output = Result<Bound<<u128 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Bound<u128>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Bound<u128>> for u128

type Output = Result<Bound<<u128 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Bound<u128>) -> Self::Output

Performs the / operation.

impl<'a, 'b> Div<&'a Bound<u16>> for &'b Bound<u16>

type Output = Result<Bound<<u16 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Bound<u16>) -> Self::Output

Performs the / operation.

impl<'a, 'b> Div<&'b Bound<u16>> for &'a u16

type Output = Result<Bound<<u16 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: &'b Bound<u16>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Bound<u16>> for Bound<u16>

type Output = Result<Bound<<u16 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Bound<u16>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Bound<u16>> for u16

type Output = Result<Bound<<u16 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Bound<u16>) -> Self::Output

Performs the / operation.

impl<'a, 'b> Div<&'a Bound<u32>> for &'b Bound<u32>

type Output = Result<Bound<<u32 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Bound<u32>) -> Self::Output

Performs the / operation.

impl<'a, 'b> Div<&'b Bound<u32>> for &'a u32

type Output = Result<Bound<<u32 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: &'b Bound<u32>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Bound<u32>> for Bound<u32>

type Output = Result<Bound<<u32 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Bound<u32>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Bound<u32>> for u32

type Output = Result<Bound<<u32 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Bound<u32>) -> Self::Output

Performs the / operation.

impl<'a, 'b> Div<&'a Bound<u64>> for &'b Bound<u64>

type Output = Result<Bound<<u64 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Bound<u64>) -> Self::Output

Performs the / operation.

impl<'a, 'b> Div<&'b Bound<u64>> for &'a u64

type Output = Result<Bound<<u64 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: &'b Bound<u64>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Bound<u64>> for Bound<u64>

type Output = Result<Bound<<u64 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Bound<u64>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Bound<u64>> for u64

type Output = Result<Bound<<u64 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Bound<u64>) -> Self::Output

Performs the / operation.

impl<'a, 'b> Div<&'a Bound<u8>> for &'b Bound<u8>

type Output = Result<Bound<<u8 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Bound<u8>) -> Self::Output

Performs the / operation.

impl<'a, 'b> Div<&'b Bound<u8>> for &'a u8

type Output = Result<Bound<<u8 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: &'b Bound<u8>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Bound<u8>> for Bound<u8>

type Output = Result<Bound<<u8 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Bound<u8>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Bound<u8>> for u8

type Output = Result<Bound<<u8 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Bound<u8>) -> Self::Output

Performs the / operation.

impl<'a, 'b> Div<&'a Bound<usize>> for &'b Bound<usize>

type Output = Result<Bound<<usize as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Bound<usize>) -> Self::Output

Performs the / operation.

impl<'a, 'b> Div<&'b Bound<usize>> for &'a usize

type Output = Result<Bound<<usize as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: &'b Bound<usize>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Bound<usize>> for Bound<usize>

type Output = Result<Bound<<usize as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Bound<usize>) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a Bound<usize>> for usize

type Output = Result<Bound<<usize as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Bound<usize>) -> Self::Output

Performs the / operation.

impl<'a, 'b> Div<&'a f32> for &'b Bound<f32>

type Output = Result<Bound<<f32 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: &'a f32) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a f32> for Bound<f32>

type Output = Result<Bound<<f32 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: &'a f32) -> Self::Output

Performs the / operation.

impl<'a, 'b> Div<&'a f64> for &'b Bound<f64>

type Output = Result<Bound<<f64 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: &'a f64) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a f64> for Bound<f64>

type Output = Result<Bound<<f64 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: &'a f64) -> Self::Output

Performs the / operation.

impl<'a, 'b> Div<&'a i128> for &'b Bound<i128>

type Output = Result<Bound<<i128 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: &'a i128) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a i128> for Bound<i128>

type Output = Result<Bound<<i128 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: &'a i128) -> Self::Output

Performs the / operation.

impl<'a, 'b> Div<&'a i16> for &'b Bound<i16>

type Output = Result<Bound<<i16 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: &'a i16) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a i16> for Bound<i16>

type Output = Result<Bound<<i16 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: &'a i16) -> Self::Output

Performs the / operation.

impl<'a, 'b> Div<&'a i32> for &'b Bound<i32>

type Output = Result<Bound<<i32 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: &'a i32) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a i32> for Bound<i32>

type Output = Result<Bound<<i32 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: &'a i32) -> Self::Output

Performs the / operation.

impl<'a, 'b> Div<&'a i64> for &'b Bound<i64>

type Output = Result<Bound<<i64 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: &'a i64) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a i64> for Bound<i64>

type Output = Result<Bound<<i64 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: &'a i64) -> Self::Output

Performs the / operation.

impl<'a, 'b> Div<&'a i8> for &'b Bound<i8>

type Output = Result<Bound<<i8 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: &'a i8) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a i8> for Bound<i8>

type Output = Result<Bound<<i8 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: &'a i8) -> Self::Output

Performs the / operation.

impl<'a, 'b> Div<&'a isize> for &'b Bound<isize>

type Output = Result<Bound<<isize as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: &'a isize) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a isize> for Bound<isize>

type Output = Result<Bound<<isize as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: &'a isize) -> Self::Output

Performs the / operation.

impl<'a, 'b> Div<&'a u128> for &'b Bound<u128>

type Output = Result<Bound<<u128 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: &'a u128) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a u128> for Bound<u128>

type Output = Result<Bound<<u128 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: &'a u128) -> Self::Output

Performs the / operation.

impl<'a, 'b> Div<&'a u16> for &'b Bound<u16>

type Output = Result<Bound<<u16 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: &'a u16) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a u16> for Bound<u16>

type Output = Result<Bound<<u16 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: &'a u16) -> Self::Output

Performs the / operation.

impl<'a, 'b> Div<&'a u32> for &'b Bound<u32>

type Output = Result<Bound<<u32 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: &'a u32) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a u32> for Bound<u32>

type Output = Result<Bound<<u32 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: &'a u32) -> Self::Output

Performs the / operation.

impl<'a, 'b> Div<&'a u64> for &'b Bound<u64>

type Output = Result<Bound<<u64 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: &'a u64) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a u64> for Bound<u64>

type Output = Result<Bound<<u64 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: &'a u64) -> Self::Output

Performs the / operation.

impl<'a, 'b> Div<&'a u8> for &'b Bound<u8>

type Output = Result<Bound<<u8 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: &'a u8) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a u8> for Bound<u8>

type Output = Result<Bound<<u8 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: &'a u8) -> Self::Output

Performs the / operation.

impl<'a, 'b> Div<&'a usize> for &'b Bound<usize>

type Output = Result<Bound<<usize as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: &'a usize) -> Self::Output

Performs the / operation.

impl<'a> Div<&'a usize> for Bound<usize>

type Output = Result<Bound<<usize as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: &'a usize) -> Self::Output

Performs the / operation.

impl<'a> Div<Bound<f32>> for &'a Bound<f32>

type Output = Result<Bound<<f32 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: Bound<f32>) -> Self::Output

Performs the / operation.

impl<'a> Div<Bound<f32>> for &'a f32

type Output = Result<Bound<<f32 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: Bound<f32>) -> Self::Output

Performs the / operation.

impl Div<Bound<f32>> for f32

type Output = Result<Bound<<f32 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: Bound<f32>) -> Self::Output

Performs the / operation.

impl<'a> Div<Bound<f64>> for &'a Bound<f64>

type Output = Result<Bound<<f64 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: Bound<f64>) -> Self::Output

Performs the / operation.

impl<'a> Div<Bound<f64>> for &'a f64

type Output = Result<Bound<<f64 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: Bound<f64>) -> Self::Output

Performs the / operation.

impl Div<Bound<f64>> for f64

type Output = Result<Bound<<f64 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: Bound<f64>) -> Self::Output

Performs the / operation.

impl<'a> Div<Bound<i128>> for &'a Bound<i128>

type Output = Result<Bound<<i128 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: Bound<i128>) -> Self::Output

Performs the / operation.

impl<'a> Div<Bound<i128>> for &'a i128

type Output = Result<Bound<<i128 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: Bound<i128>) -> Self::Output

Performs the / operation.

impl Div<Bound<i128>> for i128

type Output = Result<Bound<<i128 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: Bound<i128>) -> Self::Output

Performs the / operation.

impl<'a> Div<Bound<i16>> for &'a Bound<i16>

type Output = Result<Bound<<i16 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: Bound<i16>) -> Self::Output

Performs the / operation.

impl<'a> Div<Bound<i16>> for &'a i16

type Output = Result<Bound<<i16 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: Bound<i16>) -> Self::Output

Performs the / operation.

impl Div<Bound<i16>> for i16

type Output = Result<Bound<<i16 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: Bound<i16>) -> Self::Output

Performs the / operation.

impl<'a> Div<Bound<i32>> for &'a Bound<i32>

type Output = Result<Bound<<i32 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: Bound<i32>) -> Self::Output

Performs the / operation.

impl<'a> Div<Bound<i32>> for &'a i32

type Output = Result<Bound<<i32 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: Bound<i32>) -> Self::Output

Performs the / operation.

impl Div<Bound<i32>> for i32

type Output = Result<Bound<<i32 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: Bound<i32>) -> Self::Output

Performs the / operation.

impl<'a> Div<Bound<i64>> for &'a Bound<i64>

type Output = Result<Bound<<i64 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: Bound<i64>) -> Self::Output

Performs the / operation.

impl<'a> Div<Bound<i64>> for &'a i64

type Output = Result<Bound<<i64 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: Bound<i64>) -> Self::Output

Performs the / operation.

impl Div<Bound<i64>> for i64

type Output = Result<Bound<<i64 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: Bound<i64>) -> Self::Output

Performs the / operation.

impl<'a> Div<Bound<i8>> for &'a Bound<i8>

type Output = Result<Bound<<i8 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: Bound<i8>) -> Self::Output

Performs the / operation.

impl<'a> Div<Bound<i8>> for &'a i8

type Output = Result<Bound<<i8 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: Bound<i8>) -> Self::Output

Performs the / operation.

impl Div<Bound<i8>> for i8

type Output = Result<Bound<<i8 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: Bound<i8>) -> Self::Output

Performs the / operation.

impl<'a> Div<Bound<isize>> for &'a Bound<isize>

type Output = Result<Bound<<isize as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: Bound<isize>) -> Self::Output

Performs the / operation.

impl<'a> Div<Bound<isize>> for &'a isize

type Output = Result<Bound<<isize as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: Bound<isize>) -> Self::Output

Performs the / operation.

impl Div<Bound<isize>> for isize

type Output = Result<Bound<<isize as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: Bound<isize>) -> Self::Output

Performs the / operation.

impl<'a> Div<Bound<u128>> for &'a Bound<u128>

type Output = Result<Bound<<u128 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: Bound<u128>) -> Self::Output

Performs the / operation.

impl<'a> Div<Bound<u128>> for &'a u128

type Output = Result<Bound<<u128 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: Bound<u128>) -> Self::Output

Performs the / operation.

impl Div<Bound<u128>> for u128

type Output = Result<Bound<<u128 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: Bound<u128>) -> Self::Output

Performs the / operation.

impl<'a> Div<Bound<u16>> for &'a Bound<u16>

type Output = Result<Bound<<u16 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: Bound<u16>) -> Self::Output

Performs the / operation.

impl<'a> Div<Bound<u16>> for &'a u16

type Output = Result<Bound<<u16 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: Bound<u16>) -> Self::Output

Performs the / operation.

impl Div<Bound<u16>> for u16

type Output = Result<Bound<<u16 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: Bound<u16>) -> Self::Output

Performs the / operation.

impl<'a> Div<Bound<u32>> for &'a Bound<u32>

type Output = Result<Bound<<u32 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: Bound<u32>) -> Self::Output

Performs the / operation.

impl<'a> Div<Bound<u32>> for &'a u32

type Output = Result<Bound<<u32 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: Bound<u32>) -> Self::Output

Performs the / operation.

impl Div<Bound<u32>> for u32

type Output = Result<Bound<<u32 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: Bound<u32>) -> Self::Output

Performs the / operation.

impl<'a> Div<Bound<u64>> for &'a Bound<u64>

type Output = Result<Bound<<u64 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: Bound<u64>) -> Self::Output

Performs the / operation.

impl<'a> Div<Bound<u64>> for &'a u64

type Output = Result<Bound<<u64 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: Bound<u64>) -> Self::Output

Performs the / operation.

impl Div<Bound<u64>> for u64

type Output = Result<Bound<<u64 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: Bound<u64>) -> Self::Output

Performs the / operation.

impl<'a> Div<Bound<u8>> for &'a Bound<u8>

type Output = Result<Bound<<u8 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: Bound<u8>) -> Self::Output

Performs the / operation.

impl<'a> Div<Bound<u8>> for &'a u8

type Output = Result<Bound<<u8 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: Bound<u8>) -> Self::Output

Performs the / operation.

impl Div<Bound<u8>> for u8

type Output = Result<Bound<<u8 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: Bound<u8>) -> Self::Output

Performs the / operation.

impl<'a> Div<Bound<usize>> for &'a Bound<usize>

type Output = Result<Bound<<usize as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: Bound<usize>) -> Self::Output

Performs the / operation.

impl<'a> Div<Bound<usize>> for &'a usize

type Output = Result<Bound<<usize as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: Bound<usize>) -> Self::Output

Performs the / operation.

impl Div<Bound<usize>> for usize

type Output = Result<Bound<<usize as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: Bound<usize>) -> Self::Output

Performs the / operation.

impl<'a> Div<f32> for &'a Bound<f32>

type Output = Result<Bound<<f32 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: f32) -> Self::Output

Performs the / operation.

impl Div<f32> for Bound<f32>

type Output = Result<Bound<<f32 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: f32) -> Self::Output

Performs the / operation.

impl<'a> Div<f64> for &'a Bound<f64>

type Output = Result<Bound<<f64 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: f64) -> Self::Output

Performs the / operation.

impl Div<f64> for Bound<f64>

type Output = Result<Bound<<f64 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: f64) -> Self::Output

Performs the / operation.

impl<'a> Div<i128> for &'a Bound<i128>

type Output = Result<Bound<<i128 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: i128) -> Self::Output

Performs the / operation.

impl Div<i128> for Bound<i128>

type Output = Result<Bound<<i128 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: i128) -> Self::Output

Performs the / operation.

impl<'a> Div<i16> for &'a Bound<i16>

type Output = Result<Bound<<i16 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: i16) -> Self::Output

Performs the / operation.

impl Div<i16> for Bound<i16>

type Output = Result<Bound<<i16 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: i16) -> Self::Output

Performs the / operation.

impl<'a> Div<i32> for &'a Bound<i32>

type Output = Result<Bound<<i32 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: i32) -> Self::Output

Performs the / operation.

impl Div<i32> for Bound<i32>

type Output = Result<Bound<<i32 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: i32) -> Self::Output

Performs the / operation.

impl<'a> Div<i64> for &'a Bound<i64>

type Output = Result<Bound<<i64 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: i64) -> Self::Output

Performs the / operation.

impl Div<i64> for Bound<i64>

type Output = Result<Bound<<i64 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: i64) -> Self::Output

Performs the / operation.

impl<'a> Div<i8> for &'a Bound<i8>

type Output = Result<Bound<<i8 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: i8) -> Self::Output

Performs the / operation.

impl Div<i8> for Bound<i8>

type Output = Result<Bound<<i8 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: i8) -> Self::Output

Performs the / operation.

impl<'a> Div<isize> for &'a Bound<isize>

type Output = Result<Bound<<isize as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: isize) -> Self::Output

Performs the / operation.

impl Div<isize> for Bound<isize>

type Output = Result<Bound<<isize as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: isize) -> Self::Output

Performs the / operation.

impl<'a> Div<u128> for &'a Bound<u128>

type Output = Result<Bound<<u128 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: u128) -> Self::Output

Performs the / operation.

impl Div<u128> for Bound<u128>

type Output = Result<Bound<<u128 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: u128) -> Self::Output

Performs the / operation.

impl<'a> Div<u16> for &'a Bound<u16>

type Output = Result<Bound<<u16 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: u16) -> Self::Output

Performs the / operation.

impl Div<u16> for Bound<u16>

type Output = Result<Bound<<u16 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: u16) -> Self::Output

Performs the / operation.

impl<'a> Div<u32> for &'a Bound<u32>

type Output = Result<Bound<<u32 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<u32> for Bound<u32>

type Output = Result<Bound<<u32 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'a> Div<u64> for &'a Bound<u64>

type Output = Result<Bound<<u64 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: u64) -> Self::Output

Performs the / operation.

impl Div<u64> for Bound<u64>

type Output = Result<Bound<<u64 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: u64) -> Self::Output

Performs the / operation.

impl<'a> Div<u8> for &'a Bound<u8>

type Output = Result<Bound<<u8 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: u8) -> Self::Output

Performs the / operation.

impl Div<u8> for Bound<u8>

type Output = Result<Bound<<u8 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: u8) -> Self::Output

Performs the / operation.

impl<'a> Div<usize> for &'a Bound<usize>

type Output = Result<Bound<<usize as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: usize) -> Self::Output

Performs the / operation.

impl Div<usize> for Bound<usize>

type Output = Result<Bound<<usize as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: usize) -> Self::Output

Performs the / operation.

impl Div for Bound<f32>

type Output = Result<Bound<<f32 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: Bound<f32>) -> Self::Output

Performs the / operation.

impl Div for Bound<f64>

type Output = Result<Bound<<f64 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: Bound<f64>) -> Self::Output

Performs the / operation.

impl Div for Bound<i128>

type Output = Result<Bound<<i128 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: Bound<i128>) -> Self::Output

Performs the / operation.

impl Div for Bound<i16>

type Output = Result<Bound<<i16 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: Bound<i16>) -> Self::Output

Performs the / operation.

impl Div for Bound<i32>

type Output = Result<Bound<<i32 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: Bound<i32>) -> Self::Output

Performs the / operation.

impl Div for Bound<i64>

type Output = Result<Bound<<i64 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: Bound<i64>) -> Self::Output

Performs the / operation.

impl Div for Bound<i8>

type Output = Result<Bound<<i8 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: Bound<i8>) -> Self::Output

Performs the / operation.

impl Div for Bound<isize>

type Output = Result<Bound<<isize as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: Bound<isize>) -> Self::Output

Performs the / operation.

impl Div for Bound<u128>

type Output = Result<Bound<<u128 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: Bound<u128>) -> Self::Output

Performs the / operation.

impl Div for Bound<u16>

type Output = Result<Bound<<u16 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: Bound<u16>) -> Self::Output

Performs the / operation.

impl Div for Bound<u32>

type Output = Result<Bound<<u32 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: Bound<u32>) -> Self::Output

Performs the / operation.

impl Div for Bound<u64>

type Output = Result<Bound<<u64 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: Bound<u64>) -> Self::Output

Performs the / operation.

impl Div for Bound<u8>

type Output = Result<Bound<<u8 as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: Bound<u8>) -> Self::Output

Performs the / operation.

impl Div for Bound<usize>

type Output = Result<Bound<<usize as Div>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: Bound<usize>) -> Self::Output

Performs the / operation.

impl<T, U> From<&Bound<U>> for Bound<T>

where ValueWrapper<T>: for<'a> From<&'a ValueWrapper<U>>,

fn from(bound: &Bound<U>) -> Self

Converts to this type from the input type.

impl<'a, 'b> Mul<&'a Bound<f32>> for &'b Bound<f32>

type Output = Result<Bound<<f32 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Bound<f32>) -> Self::Output

Performs the * operation.

impl<'a, 'b> Mul<&'b Bound<f32>> for &'a f32

type Output = Result<Bound<<f32 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b Bound<f32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Bound<f32>> for Bound<f32>

type Output = Result<Bound<<f32 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Bound<f32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Bound<f32>> for f32

type Output = Result<Bound<<f32 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Bound<f32>) -> Self::Output

Performs the * operation.

impl<'a, 'b> Mul<&'a Bound<f64>> for &'b Bound<f64>

type Output = Result<Bound<<f64 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Bound<f64>) -> Self::Output

Performs the * operation.

impl<'a, 'b> Mul<&'b Bound<f64>> for &'a f64

type Output = Result<Bound<<f64 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b Bound<f64>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Bound<f64>> for Bound<f64>

type Output = Result<Bound<<f64 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Bound<f64>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Bound<f64>> for f64

type Output = Result<Bound<<f64 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Bound<f64>) -> Self::Output

Performs the * operation.

impl<'a, 'b> Mul<&'a Bound<i128>> for &'b Bound<i128>

type Output = Result<Bound<<i128 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Bound<i128>) -> Self::Output

Performs the * operation.

impl<'a, 'b> Mul<&'b Bound<i128>> for &'a i128

type Output = Result<Bound<<i128 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b Bound<i128>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Bound<i128>> for Bound<i128>

type Output = Result<Bound<<i128 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Bound<i128>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Bound<i128>> for i128

type Output = Result<Bound<<i128 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Bound<i128>) -> Self::Output

Performs the * operation.

impl<'a, 'b> Mul<&'a Bound<i16>> for &'b Bound<i16>

type Output = Result<Bound<<i16 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Bound<i16>) -> Self::Output

Performs the * operation.

impl<'a, 'b> Mul<&'b Bound<i16>> for &'a i16

type Output = Result<Bound<<i16 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b Bound<i16>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Bound<i16>> for Bound<i16>

type Output = Result<Bound<<i16 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Bound<i16>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Bound<i16>> for i16

type Output = Result<Bound<<i16 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Bound<i16>) -> Self::Output

Performs the * operation.

impl<'a, 'b> Mul<&'a Bound<i32>> for &'b Bound<i32>

type Output = Result<Bound<<i32 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Bound<i32>) -> Self::Output

Performs the * operation.

impl<'a, 'b> Mul<&'b Bound<i32>> for &'a i32

type Output = Result<Bound<<i32 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b Bound<i32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Bound<i32>> for Bound<i32>

type Output = Result<Bound<<i32 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Bound<i32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Bound<i32>> for i32

type Output = Result<Bound<<i32 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Bound<i32>) -> Self::Output

Performs the * operation.

impl<'a, 'b> Mul<&'a Bound<i64>> for &'b Bound<i64>

type Output = Result<Bound<<i64 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Bound<i64>) -> Self::Output

Performs the * operation.

impl<'a, 'b> Mul<&'b Bound<i64>> for &'a i64

type Output = Result<Bound<<i64 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b Bound<i64>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Bound<i64>> for Bound<i64>

type Output = Result<Bound<<i64 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Bound<i64>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Bound<i64>> for i64

type Output = Result<Bound<<i64 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Bound<i64>) -> Self::Output

Performs the * operation.

impl<'a, 'b> Mul<&'a Bound<i8>> for &'b Bound<i8>

type Output = Result<Bound<<i8 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Bound<i8>) -> Self::Output

Performs the * operation.

impl<'a, 'b> Mul<&'b Bound<i8>> for &'a i8

type Output = Result<Bound<<i8 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b Bound<i8>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Bound<i8>> for Bound<i8>

type Output = Result<Bound<<i8 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Bound<i8>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Bound<i8>> for i8

type Output = Result<Bound<<i8 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Bound<i8>) -> Self::Output

Performs the * operation.

impl<'a, 'b> Mul<&'a Bound<isize>> for &'b Bound<isize>

type Output = Result<Bound<<isize as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Bound<isize>) -> Self::Output

Performs the * operation.

impl<'a, 'b> Mul<&'b Bound<isize>> for &'a isize

type Output = Result<Bound<<isize as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b Bound<isize>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Bound<isize>> for Bound<isize>

type Output = Result<Bound<<isize as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Bound<isize>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Bound<isize>> for isize

type Output = Result<Bound<<isize as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Bound<isize>) -> Self::Output

Performs the * operation.

impl<'a, 'b> Mul<&'a Bound<u128>> for &'b Bound<u128>

type Output = Result<Bound<<u128 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Bound<u128>) -> Self::Output

Performs the * operation.

impl<'a, 'b> Mul<&'b Bound<u128>> for &'a u128

type Output = Result<Bound<<u128 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b Bound<u128>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Bound<u128>> for Bound<u128>

type Output = Result<Bound<<u128 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Bound<u128>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Bound<u128>> for u128

type Output = Result<Bound<<u128 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Bound<u128>) -> Self::Output

Performs the * operation.

impl<'a, 'b> Mul<&'a Bound<u16>> for &'b Bound<u16>

type Output = Result<Bound<<u16 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Bound<u16>) -> Self::Output

Performs the * operation.

impl<'a, 'b> Mul<&'b Bound<u16>> for &'a u16

type Output = Result<Bound<<u16 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b Bound<u16>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Bound<u16>> for Bound<u16>

type Output = Result<Bound<<u16 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Bound<u16>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Bound<u16>> for u16

type Output = Result<Bound<<u16 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Bound<u16>) -> Self::Output

Performs the * operation.

impl<'a, 'b> Mul<&'a Bound<u32>> for &'b Bound<u32>

type Output = Result<Bound<<u32 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Bound<u32>) -> Self::Output

Performs the * operation.

impl<'a, 'b> Mul<&'b Bound<u32>> for &'a u32

type Output = Result<Bound<<u32 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b Bound<u32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Bound<u32>> for Bound<u32>

type Output = Result<Bound<<u32 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Bound<u32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Bound<u32>> for u32

type Output = Result<Bound<<u32 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Bound<u32>) -> Self::Output

Performs the * operation.

impl<'a, 'b> Mul<&'a Bound<u64>> for &'b Bound<u64>

type Output = Result<Bound<<u64 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Bound<u64>) -> Self::Output

Performs the * operation.

impl<'a, 'b> Mul<&'b Bound<u64>> for &'a u64

type Output = Result<Bound<<u64 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b Bound<u64>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Bound<u64>> for Bound<u64>

type Output = Result<Bound<<u64 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Bound<u64>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Bound<u64>> for u64

type Output = Result<Bound<<u64 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Bound<u64>) -> Self::Output

Performs the * operation.

impl<'a, 'b> Mul<&'a Bound<u8>> for &'b Bound<u8>

type Output = Result<Bound<<u8 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Bound<u8>) -> Self::Output

Performs the * operation.

impl<'a, 'b> Mul<&'b Bound<u8>> for &'a u8

type Output = Result<Bound<<u8 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b Bound<u8>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Bound<u8>> for Bound<u8>

type Output = Result<Bound<<u8 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Bound<u8>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Bound<u8>> for u8

type Output = Result<Bound<<u8 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Bound<u8>) -> Self::Output

Performs the * operation.

impl<'a, 'b> Mul<&'a Bound<usize>> for &'b Bound<usize>

type Output = Result<Bound<<usize as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Bound<usize>) -> Self::Output

Performs the * operation.

impl<'a, 'b> Mul<&'b Bound<usize>> for &'a usize

type Output = Result<Bound<<usize as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b Bound<usize>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Bound<usize>> for Bound<usize>

type Output = Result<Bound<<usize as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Bound<usize>) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a Bound<usize>> for usize

type Output = Result<Bound<<usize as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Bound<usize>) -> Self::Output

Performs the * operation.

impl<'a, 'b> Mul<&'a f32> for &'b Bound<f32>

type Output = Result<Bound<<f32 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a f32) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a f32> for Bound<f32>

type Output = Result<Bound<<f32 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a f32) -> Self::Output

Performs the * operation.

impl<'a, 'b> Mul<&'a f64> for &'b Bound<f64>

type Output = Result<Bound<<f64 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a f64) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a f64> for Bound<f64>

type Output = Result<Bound<<f64 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a f64) -> Self::Output

Performs the * operation.

impl<'a, 'b> Mul<&'a i128> for &'b Bound<i128>

type Output = Result<Bound<<i128 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a i128) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a i128> for Bound<i128>

type Output = Result<Bound<<i128 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a i128) -> Self::Output

Performs the * operation.

impl<'a, 'b> Mul<&'a i16> for &'b Bound<i16>

type Output = Result<Bound<<i16 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a i16) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a i16> for Bound<i16>

type Output = Result<Bound<<i16 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a i16) -> Self::Output

Performs the * operation.

impl<'a, 'b> Mul<&'a i32> for &'b Bound<i32>

type Output = Result<Bound<<i32 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a i32) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a i32> for Bound<i32>

type Output = Result<Bound<<i32 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a i32) -> Self::Output

Performs the * operation.

impl<'a, 'b> Mul<&'a i64> for &'b Bound<i64>

type Output = Result<Bound<<i64 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a i64) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a i64> for Bound<i64>

type Output = Result<Bound<<i64 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a i64) -> Self::Output

Performs the * operation.

impl<'a, 'b> Mul<&'a i8> for &'b Bound<i8>

type Output = Result<Bound<<i8 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a i8) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a i8> for Bound<i8>

type Output = Result<Bound<<i8 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a i8) -> Self::Output

Performs the * operation.

impl<'a, 'b> Mul<&'a isize> for &'b Bound<isize>

type Output = Result<Bound<<isize as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a isize) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a isize> for Bound<isize>

type Output = Result<Bound<<isize as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a isize) -> Self::Output

Performs the * operation.

impl<'a, 'b> Mul<&'a u128> for &'b Bound<u128>

type Output = Result<Bound<<u128 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a u128) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a u128> for Bound<u128>

type Output = Result<Bound<<u128 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a u128) -> Self::Output

Performs the * operation.

impl<'a, 'b> Mul<&'a u16> for &'b Bound<u16>

type Output = Result<Bound<<u16 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a u16) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a u16> for Bound<u16>

type Output = Result<Bound<<u16 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a u16) -> Self::Output

Performs the * operation.

impl<'a, 'b> Mul<&'a u32> for &'b Bound<u32>

type Output = Result<Bound<<u32 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a u32) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a u32> for Bound<u32>

type Output = Result<Bound<<u32 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a u32) -> Self::Output

Performs the * operation.

impl<'a, 'b> Mul<&'a u64> for &'b Bound<u64>

type Output = Result<Bound<<u64 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a u64) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a u64> for Bound<u64>

type Output = Result<Bound<<u64 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a u64) -> Self::Output

Performs the * operation.

impl<'a, 'b> Mul<&'a u8> for &'b Bound<u8>

type Output = Result<Bound<<u8 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a u8) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a u8> for Bound<u8>

type Output = Result<Bound<<u8 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a u8) -> Self::Output

Performs the * operation.

impl<'a, 'b> Mul<&'a usize> for &'b Bound<usize>

type Output = Result<Bound<<usize as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a usize) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a usize> for Bound<usize>

type Output = Result<Bound<<usize as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a usize) -> Self::Output

Performs the * operation.

impl<'a> Mul<Bound<f32>> for &'a Bound<f32>

type Output = Result<Bound<<f32 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: Bound<f32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Bound<f32>> for &'a f32

type Output = Result<Bound<<f32 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: Bound<f32>) -> Self::Output

Performs the * operation.

impl Mul<Bound<f32>> for f32

type Output = Result<Bound<<f32 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: Bound<f32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Bound<f64>> for &'a Bound<f64>

type Output = Result<Bound<<f64 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: Bound<f64>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Bound<f64>> for &'a f64

type Output = Result<Bound<<f64 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: Bound<f64>) -> Self::Output

Performs the * operation.

impl Mul<Bound<f64>> for f64

type Output = Result<Bound<<f64 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: Bound<f64>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Bound<i128>> for &'a Bound<i128>

type Output = Result<Bound<<i128 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: Bound<i128>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Bound<i128>> for &'a i128

type Output = Result<Bound<<i128 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: Bound<i128>) -> Self::Output

Performs the * operation.

impl Mul<Bound<i128>> for i128

type Output = Result<Bound<<i128 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: Bound<i128>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Bound<i16>> for &'a Bound<i16>

type Output = Result<Bound<<i16 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: Bound<i16>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Bound<i16>> for &'a i16

type Output = Result<Bound<<i16 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: Bound<i16>) -> Self::Output

Performs the * operation.

impl Mul<Bound<i16>> for i16

type Output = Result<Bound<<i16 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: Bound<i16>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Bound<i32>> for &'a Bound<i32>

type Output = Result<Bound<<i32 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: Bound<i32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Bound<i32>> for &'a i32

type Output = Result<Bound<<i32 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: Bound<i32>) -> Self::Output

Performs the * operation.

impl Mul<Bound<i32>> for i32

type Output = Result<Bound<<i32 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: Bound<i32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Bound<i64>> for &'a Bound<i64>

type Output = Result<Bound<<i64 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: Bound<i64>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Bound<i64>> for &'a i64

type Output = Result<Bound<<i64 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: Bound<i64>) -> Self::Output

Performs the * operation.

impl Mul<Bound<i64>> for i64

type Output = Result<Bound<<i64 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: Bound<i64>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Bound<i8>> for &'a Bound<i8>

type Output = Result<Bound<<i8 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: Bound<i8>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Bound<i8>> for &'a i8

type Output = Result<Bound<<i8 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: Bound<i8>) -> Self::Output

Performs the * operation.

impl Mul<Bound<i8>> for i8

type Output = Result<Bound<<i8 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: Bound<i8>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Bound<isize>> for &'a Bound<isize>

type Output = Result<Bound<<isize as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: Bound<isize>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Bound<isize>> for &'a isize

type Output = Result<Bound<<isize as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: Bound<isize>) -> Self::Output

Performs the * operation.

impl Mul<Bound<isize>> for isize

type Output = Result<Bound<<isize as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: Bound<isize>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Bound<u128>> for &'a Bound<u128>

type Output = Result<Bound<<u128 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: Bound<u128>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Bound<u128>> for &'a u128

type Output = Result<Bound<<u128 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: Bound<u128>) -> Self::Output

Performs the * operation.

impl Mul<Bound<u128>> for u128

type Output = Result<Bound<<u128 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: Bound<u128>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Bound<u16>> for &'a Bound<u16>

type Output = Result<Bound<<u16 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: Bound<u16>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Bound<u16>> for &'a u16

type Output = Result<Bound<<u16 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: Bound<u16>) -> Self::Output

Performs the * operation.

impl Mul<Bound<u16>> for u16

type Output = Result<Bound<<u16 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: Bound<u16>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Bound<u32>> for &'a Bound<u32>

type Output = Result<Bound<<u32 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: Bound<u32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Bound<u32>> for &'a u32

type Output = Result<Bound<<u32 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: Bound<u32>) -> Self::Output

Performs the * operation.

impl Mul<Bound<u32>> for u32

type Output = Result<Bound<<u32 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: Bound<u32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Bound<u64>> for &'a Bound<u64>

type Output = Result<Bound<<u64 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: Bound<u64>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Bound<u64>> for &'a u64

type Output = Result<Bound<<u64 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: Bound<u64>) -> Self::Output

Performs the * operation.

impl Mul<Bound<u64>> for u64

type Output = Result<Bound<<u64 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: Bound<u64>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Bound<u8>> for &'a Bound<u8>

type Output = Result<Bound<<u8 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: Bound<u8>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Bound<u8>> for &'a u8

type Output = Result<Bound<<u8 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: Bound<u8>) -> Self::Output

Performs the * operation.

impl Mul<Bound<u8>> for u8

type Output = Result<Bound<<u8 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: Bound<u8>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Bound<usize>> for &'a Bound<usize>

type Output = Result<Bound<<usize as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: Bound<usize>) -> Self::Output

Performs the * operation.

impl<'a> Mul<Bound<usize>> for &'a usize

type Output = Result<Bound<<usize as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: Bound<usize>) -> Self::Output

Performs the * operation.

impl Mul<Bound<usize>> for usize

type Output = Result<Bound<<usize as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: Bound<usize>) -> Self::Output

Performs the * operation.

impl<'a> Mul<f32> for &'a Bound<f32>

type Output = Result<Bound<<f32 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: f32) -> Self::Output

Performs the * operation.

impl Mul<f32> for Bound<f32>

type Output = Result<Bound<<f32 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: f32) -> Self::Output

Performs the * operation.

impl<'a> Mul<f64> for &'a Bound<f64>

type Output = Result<Bound<<f64 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: f64) -> Self::Output

Performs the * operation.

impl Mul<f64> for Bound<f64>

type Output = Result<Bound<<f64 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: f64) -> Self::Output

Performs the * operation.

impl<'a> Mul<i128> for &'a Bound<i128>

type Output = Result<Bound<<i128 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: i128) -> Self::Output

Performs the * operation.

impl Mul<i128> for Bound<i128>

type Output = Result<Bound<<i128 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: i128) -> Self::Output

Performs the * operation.

impl<'a> Mul<i16> for &'a Bound<i16>

type Output = Result<Bound<<i16 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: i16) -> Self::Output

Performs the * operation.

impl Mul<i16> for Bound<i16>

type Output = Result<Bound<<i16 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: i16) -> Self::Output

Performs the * operation.

impl<'a> Mul<i32> for &'a Bound<i32>

type Output = Result<Bound<<i32 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: i32) -> Self::Output

Performs the * operation.

impl Mul<i32> for Bound<i32>

type Output = Result<Bound<<i32 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: i32) -> Self::Output

Performs the * operation.

impl<'a> Mul<i64> for &'a Bound<i64>

type Output = Result<Bound<<i64 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: i64) -> Self::Output

Performs the * operation.

impl Mul<i64> for Bound<i64>

type Output = Result<Bound<<i64 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: i64) -> Self::Output

Performs the * operation.

impl<'a> Mul<i8> for &'a Bound<i8>

type Output = Result<Bound<<i8 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: i8) -> Self::Output

Performs the * operation.

impl Mul<i8> for Bound<i8>

type Output = Result<Bound<<i8 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: i8) -> Self::Output

Performs the * operation.

impl<'a> Mul<isize> for &'a Bound<isize>

type Output = Result<Bound<<isize as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: isize) -> Self::Output

Performs the * operation.

impl Mul<isize> for Bound<isize>

type Output = Result<Bound<<isize as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: isize) -> Self::Output

Performs the * operation.

impl<'a> Mul<u128> for &'a Bound<u128>

type Output = Result<Bound<<u128 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: u128) -> Self::Output

Performs the * operation.

impl Mul<u128> for Bound<u128>

type Output = Result<Bound<<u128 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: u128) -> Self::Output

Performs the * operation.

impl<'a> Mul<u16> for &'a Bound<u16>

type Output = Result<Bound<<u16 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: u16) -> Self::Output

Performs the * operation.

impl Mul<u16> for Bound<u16>

type Output = Result<Bound<<u16 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: u16) -> Self::Output

Performs the * operation.

impl<'a> Mul<u32> for &'a Bound<u32>

type Output = Result<Bound<<u32 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<u32> for Bound<u32>

type Output = Result<Bound<<u32 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a> Mul<u64> for &'a Bound<u64>

type Output = Result<Bound<<u64 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: u64) -> Self::Output

Performs the * operation.

impl Mul<u64> for Bound<u64>

type Output = Result<Bound<<u64 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: u64) -> Self::Output

Performs the * operation.

impl<'a> Mul<u8> for &'a Bound<u8>

type Output = Result<Bound<<u8 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: u8) -> Self::Output

Performs the * operation.

impl Mul<u8> for Bound<u8>

type Output = Result<Bound<<u8 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: u8) -> Self::Output

Performs the * operation.

impl<'a> Mul<usize> for &'a Bound<usize>

type Output = Result<Bound<<usize as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: usize) -> Self::Output

Performs the * operation.

impl Mul<usize> for Bound<usize>

type Output = Result<Bound<<usize as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: usize) -> Self::Output

Performs the * operation.

impl Mul for Bound<f32>

type Output = Result<Bound<<f32 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: Bound<f32>) -> Self::Output

Performs the * operation.

impl Mul for Bound<f64>

type Output = Result<Bound<<f64 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: Bound<f64>) -> Self::Output

Performs the * operation.

impl Mul for Bound<i128>

type Output = Result<Bound<<i128 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: Bound<i128>) -> Self::Output

Performs the * operation.

impl Mul for Bound<i16>

type Output = Result<Bound<<i16 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: Bound<i16>) -> Self::Output

Performs the * operation.

impl Mul for Bound<i32>

type Output = Result<Bound<<i32 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: Bound<i32>) -> Self::Output

Performs the * operation.

impl Mul for Bound<i64>

type Output = Result<Bound<<i64 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: Bound<i64>) -> Self::Output

Performs the * operation.

impl Mul for Bound<i8>

type Output = Result<Bound<<i8 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: Bound<i8>) -> Self::Output

Performs the * operation.

impl Mul for Bound<isize>

type Output = Result<Bound<<isize as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: Bound<isize>) -> Self::Output

Performs the * operation.

impl Mul for Bound<u128>

type Output = Result<Bound<<u128 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: Bound<u128>) -> Self::Output

Performs the * operation.

impl Mul for Bound<u16>

type Output = Result<Bound<<u16 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: Bound<u16>) -> Self::Output

Performs the * operation.

impl Mul for Bound<u32>

type Output = Result<Bound<<u32 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: Bound<u32>) -> Self::Output

Performs the * operation.

impl Mul for Bound<u64>

type Output = Result<Bound<<u64 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: Bound<u64>) -> Self::Output

Performs the * operation.

impl Mul for Bound<u8>

type Output = Result<Bound<<u8 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: Bound<u8>) -> Self::Output

Performs the * operation.

impl Mul for Bound<usize>

type Output = Result<Bound<<usize as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: Bound<usize>) -> Self::Output

Performs the * operation.

impl<'a> Neg for &'a Bound<f32>

type Output = Result<Bound<<f32 as Neg>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<'a> Neg for &'a Bound<f64>

type Output = Result<Bound<<f64 as Neg>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<'a> Neg for &'a Bound<i128>

type Output = Result<Bound<<i128 as Neg>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<'a> Neg for &'a Bound<i16>

type Output = Result<Bound<<i16 as Neg>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<'a> Neg for &'a Bound<i32>

type Output = Result<Bound<<i32 as Neg>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<'a> Neg for &'a Bound<i64>

type Output = Result<Bound<<i64 as Neg>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<'a> Neg for &'a Bound<i8>

type Output = Result<Bound<<i8 as Neg>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<'a> Neg for &'a Bound<isize>

type Output = Result<Bound<<isize as Neg>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl Neg for Bound<f32>

type Output = Result<Bound<<f32 as Neg>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl Neg for Bound<f64>

type Output = Result<Bound<<f64 as Neg>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl Neg for Bound<i128>

type Output = Result<Bound<<i128 as Neg>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl Neg for Bound<i16>

type Output = Result<Bound<<i16 as Neg>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl Neg for Bound<i32>

type Output = Result<Bound<<i32 as Neg>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl Neg for Bound<i64>

type Output = Result<Bound<<i64 as Neg>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl Neg for Bound<i8>

type Output = Result<Bound<<i8 as Neg>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl Neg for Bound<isize>

type Output = Result<Bound<<isize as Neg>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<T, U> PartialEq<Bound<U>> for Bound<T>

where ValueWrapper<T>: PartialEq<ValueWrapper<U>>,

fn eq(&self, other: &Bound<U>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T, U> PartialEq<U> for Bound<T>

where ValueWrapper<T>: PartialEq<U>,

fn eq(&self, other: &U) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, 'b> Sub<&'a Bound<f32>> for &'b Bound<f32>

type Output = Result<Bound<<f32 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Bound<f32>) -> Self::Output

Performs the - operation.

impl<'a, 'b> Sub<&'b Bound<f32>> for &'a f32

type Output = Result<Bound<<f32 as Sub<&'b f32>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b Bound<f32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Bound<f32>> for Bound<f32>

type Output = Result<Bound<<f32 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Bound<f32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Bound<f32>> for f32

type Output = Result<Bound<<f32 as Sub<&'a f32>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Bound<f32>) -> Self::Output

Performs the - operation.

impl<'a, 'b> Sub<&'a Bound<f64>> for &'b Bound<f64>

type Output = Result<Bound<<f64 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Bound<f64>) -> Self::Output

Performs the - operation.

impl<'a, 'b> Sub<&'b Bound<f64>> for &'a f64

type Output = Result<Bound<<f64 as Sub<&'b f64>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b Bound<f64>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Bound<f64>> for Bound<f64>

type Output = Result<Bound<<f64 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Bound<f64>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Bound<f64>> for f64

type Output = Result<Bound<<f64 as Sub<&'a f64>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Bound<f64>) -> Self::Output

Performs the - operation.

impl<'a, 'b> Sub<&'a Bound<i128>> for &'b Bound<i128>

type Output = Result<Bound<<i128 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Bound<i128>) -> Self::Output

Performs the - operation.

impl<'a, 'b> Sub<&'b Bound<i128>> for &'a i128

type Output = Result<Bound<<i128 as Sub<&'b i128>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b Bound<i128>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Bound<i128>> for Bound<i128>

type Output = Result<Bound<<i128 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Bound<i128>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Bound<i128>> for i128

type Output = Result<Bound<<i128 as Sub<&'a i128>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Bound<i128>) -> Self::Output

Performs the - operation.

impl<'a, 'b> Sub<&'a Bound<i16>> for &'b Bound<i16>

type Output = Result<Bound<<i16 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Bound<i16>) -> Self::Output

Performs the - operation.

impl<'a, 'b> Sub<&'b Bound<i16>> for &'a i16

type Output = Result<Bound<<i16 as Sub<&'b i16>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b Bound<i16>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Bound<i16>> for Bound<i16>

type Output = Result<Bound<<i16 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Bound<i16>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Bound<i16>> for i16

type Output = Result<Bound<<i16 as Sub<&'a i16>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Bound<i16>) -> Self::Output

Performs the - operation.

impl<'a, 'b> Sub<&'a Bound<i32>> for &'b Bound<i32>

type Output = Result<Bound<<i32 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Bound<i32>) -> Self::Output

Performs the - operation.

impl<'a, 'b> Sub<&'b Bound<i32>> for &'a i32

type Output = Result<Bound<<i32 as Sub<&'b i32>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b Bound<i32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Bound<i32>> for Bound<i32>

type Output = Result<Bound<<i32 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Bound<i32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Bound<i32>> for i32

type Output = Result<Bound<<i32 as Sub<&'a i32>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Bound<i32>) -> Self::Output

Performs the - operation.

impl<'a, 'b> Sub<&'a Bound<i64>> for &'b Bound<i64>

type Output = Result<Bound<<i64 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Bound<i64>) -> Self::Output

Performs the - operation.

impl<'a, 'b> Sub<&'b Bound<i64>> for &'a i64

type Output = Result<Bound<<i64 as Sub<&'b i64>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b Bound<i64>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Bound<i64>> for Bound<i64>

type Output = Result<Bound<<i64 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Bound<i64>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Bound<i64>> for i64

type Output = Result<Bound<<i64 as Sub<&'a i64>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Bound<i64>) -> Self::Output

Performs the - operation.

impl<'a, 'b> Sub<&'a Bound<i8>> for &'b Bound<i8>

type Output = Result<Bound<<i8 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Bound<i8>) -> Self::Output

Performs the - operation.

impl<'a, 'b> Sub<&'b Bound<i8>> for &'a i8

type Output = Result<Bound<<i8 as Sub<&'b i8>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b Bound<i8>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Bound<i8>> for Bound<i8>

type Output = Result<Bound<<i8 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Bound<i8>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Bound<i8>> for i8

type Output = Result<Bound<<i8 as Sub<&'a i8>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Bound<i8>) -> Self::Output

Performs the - operation.

impl<'a, 'b> Sub<&'a Bound<isize>> for &'b Bound<isize>

type Output = Result<Bound<<isize as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Bound<isize>) -> Self::Output

Performs the - operation.

impl<'a, 'b> Sub<&'b Bound<isize>> for &'a isize

type Output = Result<Bound<<isize as Sub<&'b isize>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b Bound<isize>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Bound<isize>> for Bound<isize>

type Output = Result<Bound<<isize as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Bound<isize>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Bound<isize>> for isize

type Output = Result<Bound<<isize as Sub<&'a isize>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Bound<isize>) -> Self::Output

Performs the - operation.

impl<'a, 'b> Sub<&'a Bound<u128>> for &'b Bound<u128>

type Output = Result<Bound<<u128 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Bound<u128>) -> Self::Output

Performs the - operation.

impl<'a, 'b> Sub<&'b Bound<u128>> for &'a u128

type Output = Result<Bound<<u128 as Sub<&'b u128>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b Bound<u128>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Bound<u128>> for Bound<u128>

type Output = Result<Bound<<u128 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Bound<u128>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Bound<u128>> for u128

type Output = Result<Bound<<u128 as Sub<&'a u128>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Bound<u128>) -> Self::Output

Performs the - operation.

impl<'a, 'b> Sub<&'a Bound<u16>> for &'b Bound<u16>

type Output = Result<Bound<<u16 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Bound<u16>) -> Self::Output

Performs the - operation.

impl<'a, 'b> Sub<&'b Bound<u16>> for &'a u16

type Output = Result<Bound<<u16 as Sub<&'b u16>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b Bound<u16>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Bound<u16>> for Bound<u16>

type Output = Result<Bound<<u16 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Bound<u16>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Bound<u16>> for u16

type Output = Result<Bound<<u16 as Sub<&'a u16>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Bound<u16>) -> Self::Output

Performs the - operation.

impl<'a, 'b> Sub<&'a Bound<u32>> for &'b Bound<u32>

type Output = Result<Bound<<u32 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Bound<u32>) -> Self::Output

Performs the - operation.

impl<'a, 'b> Sub<&'b Bound<u32>> for &'a u32

type Output = Result<Bound<<u32 as Sub<&'b u32>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b Bound<u32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Bound<u32>> for Bound<u32>

type Output = Result<Bound<<u32 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Bound<u32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Bound<u32>> for u32

type Output = Result<Bound<<u32 as Sub<&'a u32>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Bound<u32>) -> Self::Output

Performs the - operation.

impl<'a, 'b> Sub<&'a Bound<u64>> for &'b Bound<u64>

type Output = Result<Bound<<u64 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Bound<u64>) -> Self::Output

Performs the - operation.

impl<'a, 'b> Sub<&'b Bound<u64>> for &'a u64

type Output = Result<Bound<<u64 as Sub<&'b u64>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b Bound<u64>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Bound<u64>> for Bound<u64>

type Output = Result<Bound<<u64 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Bound<u64>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Bound<u64>> for u64

type Output = Result<Bound<<u64 as Sub<&'a u64>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Bound<u64>) -> Self::Output

Performs the - operation.

impl<'a, 'b> Sub<&'a Bound<u8>> for &'b Bound<u8>

type Output = Result<Bound<<u8 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Bound<u8>) -> Self::Output

Performs the - operation.

impl<'a, 'b> Sub<&'b Bound<u8>> for &'a u8

type Output = Result<Bound<<u8 as Sub<&'b u8>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b Bound<u8>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Bound<u8>> for Bound<u8>

type Output = Result<Bound<<u8 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Bound<u8>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Bound<u8>> for u8

type Output = Result<Bound<<u8 as Sub<&'a u8>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Bound<u8>) -> Self::Output

Performs the - operation.

impl<'a, 'b> Sub<&'a Bound<usize>> for &'b Bound<usize>

type Output = Result<Bound<<usize as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Bound<usize>) -> Self::Output

Performs the - operation.

impl<'a, 'b> Sub<&'b Bound<usize>> for &'a usize

type Output = Result<Bound<<usize as Sub<&'b usize>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b Bound<usize>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Bound<usize>> for Bound<usize>

type Output = Result<Bound<<usize as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Bound<usize>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Bound<usize>> for usize

type Output = Result<Bound<<usize as Sub<&'a usize>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Bound<usize>) -> Self::Output

Performs the - operation.

impl<'a, 'b> Sub<&'a Duration> for &'b Bound<Duration>

type Output = Result<Bound<<Duration as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Duration) -> Self::Output

Performs the - operation.

impl<'a, 'b> Sub<&'a Duration> for &'b Bound<Instant>

type Output = Result<Bound<<Instant as Sub<Duration>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Duration) -> Self::Output

Performs the - operation.

impl<'a, 'b> Sub<&'a Duration> for &'b Bound<NaiveDateTime>

type Output = Result<Bound<<NaiveDateTime as Sub<Duration>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Duration) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Duration> for Bound<Duration>

type Output = Result<Bound<<Duration as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Duration) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Duration> for Bound<Instant>

type Output = Result<Bound<<Instant as Sub<Duration>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Duration) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Duration> for Bound<NaiveDateTime>

type Output = Result<Bound<<NaiveDateTime as Sub<Duration>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Duration) -> Self::Output

Performs the - operation.

impl<'a, 'b> Sub<&'a f32> for &'b Bound<f32>

type Output = Result<Bound<<f32 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a f32) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a f32> for Bound<f32>

type Output = Result<Bound<<f32 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a f32) -> Self::Output

Performs the - operation.

impl<'a, 'b> Sub<&'a f64> for &'b Bound<f64>

type Output = Result<Bound<<f64 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a f64) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a f64> for Bound<f64>

type Output = Result<Bound<<f64 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a f64) -> Self::Output

Performs the - operation.

impl<'a, 'b> Sub<&'a i128> for &'b Bound<i128>

type Output = Result<Bound<<i128 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a i128) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a i128> for Bound<i128>

type Output = Result<Bound<<i128 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a i128) -> Self::Output

Performs the - operation.

impl<'a, 'b> Sub<&'a i16> for &'b Bound<i16>

type Output = Result<Bound<<i16 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a i16) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a i16> for Bound<i16>

type Output = Result<Bound<<i16 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a i16) -> Self::Output

Performs the - operation.

impl<'a, 'b> Sub<&'a i32> for &'b Bound<i32>

type Output = Result<Bound<<i32 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a i32) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a i32> for Bound<i32>

type Output = Result<Bound<<i32 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a i32) -> Self::Output

Performs the - operation.

impl<'a, 'b> Sub<&'a i64> for &'b Bound<i64>

type Output = Result<Bound<<i64 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a i64) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a i64> for Bound<i64>

type Output = Result<Bound<<i64 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a i64) -> Self::Output

Performs the - operation.

impl<'a, 'b> Sub<&'a i8> for &'b Bound<i8>

type Output = Result<Bound<<i8 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a i8) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a i8> for Bound<i8>

type Output = Result<Bound<<i8 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a i8) -> Self::Output

Performs the - operation.

impl<'a, 'b> Sub<&'a isize> for &'b Bound<isize>

type Output = Result<Bound<<isize as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a isize) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a isize> for Bound<isize>

type Output = Result<Bound<<isize as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a isize) -> Self::Output

Performs the - operation.

impl<'a, 'b> Sub<&'a u128> for &'b Bound<u128>

type Output = Result<Bound<<u128 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a u128) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a u128> for Bound<u128>

type Output = Result<Bound<<u128 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a u128) -> Self::Output

Performs the - operation.

impl<'a, 'b> Sub<&'a u16> for &'b Bound<u16>

type Output = Result<Bound<<u16 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a u16) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a u16> for Bound<u16>

type Output = Result<Bound<<u16 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a u16) -> Self::Output

Performs the - operation.

impl<'a, 'b> Sub<&'a u32> for &'b Bound<u32>

type Output = Result<Bound<<u32 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a u32) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a u32> for Bound<u32>

type Output = Result<Bound<<u32 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a u32) -> Self::Output

Performs the - operation.

impl<'a, 'b> Sub<&'a u64> for &'b Bound<u64>

type Output = Result<Bound<<u64 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a u64) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a u64> for Bound<u64>

type Output = Result<Bound<<u64 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a u64) -> Self::Output

Performs the - operation.

impl<'a, 'b> Sub<&'a u8> for &'b Bound<u8>

type Output = Result<Bound<<u8 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a u8) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a u8> for Bound<u8>

type Output = Result<Bound<<u8 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a u8) -> Self::Output

Performs the - operation.

impl<'a, 'b> Sub<&'a usize> for &'b Bound<usize>

type Output = Result<Bound<<usize as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a usize) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a usize> for Bound<usize>

type Output = Result<Bound<<usize as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a usize) -> Self::Output

Performs the - operation.

impl<'a> Sub<Bound<f32>> for &'a Bound<f32>

type Output = Result<Bound<<f32 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: Bound<f32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Bound<f32>> for &'a f32

type Output = Result<Bound<<f32 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: Bound<f32>) -> Self::Output

Performs the - operation.

impl Sub<Bound<f32>> for f32

type Output = Result<Bound<<f32 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: Bound<f32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Bound<f64>> for &'a Bound<f64>

type Output = Result<Bound<<f64 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: Bound<f64>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Bound<f64>> for &'a f64

type Output = Result<Bound<<f64 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: Bound<f64>) -> Self::Output

Performs the - operation.

impl Sub<Bound<f64>> for f64

type Output = Result<Bound<<f64 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: Bound<f64>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Bound<i128>> for &'a Bound<i128>

type Output = Result<Bound<<i128 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: Bound<i128>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Bound<i128>> for &'a i128

type Output = Result<Bound<<i128 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: Bound<i128>) -> Self::Output

Performs the - operation.

impl Sub<Bound<i128>> for i128

type Output = Result<Bound<<i128 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: Bound<i128>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Bound<i16>> for &'a Bound<i16>

type Output = Result<Bound<<i16 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: Bound<i16>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Bound<i16>> for &'a i16

type Output = Result<Bound<<i16 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: Bound<i16>) -> Self::Output

Performs the - operation.

impl Sub<Bound<i16>> for i16

type Output = Result<Bound<<i16 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: Bound<i16>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Bound<i32>> for &'a Bound<i32>

type Output = Result<Bound<<i32 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: Bound<i32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Bound<i32>> for &'a i32

type Output = Result<Bound<<i32 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: Bound<i32>) -> Self::Output

Performs the - operation.

impl Sub<Bound<i32>> for i32

type Output = Result<Bound<<i32 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: Bound<i32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Bound<i64>> for &'a Bound<i64>

type Output = Result<Bound<<i64 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: Bound<i64>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Bound<i64>> for &'a i64

type Output = Result<Bound<<i64 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: Bound<i64>) -> Self::Output

Performs the - operation.

impl Sub<Bound<i64>> for i64

type Output = Result<Bound<<i64 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: Bound<i64>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Bound<i8>> for &'a Bound<i8>

type Output = Result<Bound<<i8 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: Bound<i8>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Bound<i8>> for &'a i8

type Output = Result<Bound<<i8 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: Bound<i8>) -> Self::Output

Performs the - operation.

impl Sub<Bound<i8>> for i8

type Output = Result<Bound<<i8 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: Bound<i8>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Bound<isize>> for &'a Bound<isize>

type Output = Result<Bound<<isize as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: Bound<isize>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Bound<isize>> for &'a isize

type Output = Result<Bound<<isize as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: Bound<isize>) -> Self::Output

Performs the - operation.

impl Sub<Bound<isize>> for isize

type Output = Result<Bound<<isize as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: Bound<isize>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Bound<u128>> for &'a Bound<u128>

type Output = Result<Bound<<u128 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: Bound<u128>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Bound<u128>> for &'a u128

type Output = Result<Bound<<u128 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: Bound<u128>) -> Self::Output

Performs the - operation.

impl Sub<Bound<u128>> for u128

type Output = Result<Bound<<u128 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: Bound<u128>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Bound<u16>> for &'a Bound<u16>

type Output = Result<Bound<<u16 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: Bound<u16>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Bound<u16>> for &'a u16

type Output = Result<Bound<<u16 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: Bound<u16>) -> Self::Output

Performs the - operation.

impl Sub<Bound<u16>> for u16

type Output = Result<Bound<<u16 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: Bound<u16>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Bound<u32>> for &'a Bound<u32>

type Output = Result<Bound<<u32 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: Bound<u32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Bound<u32>> for &'a u32

type Output = Result<Bound<<u32 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: Bound<u32>) -> Self::Output

Performs the - operation.

impl Sub<Bound<u32>> for u32

type Output = Result<Bound<<u32 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: Bound<u32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Bound<u64>> for &'a Bound<u64>

type Output = Result<Bound<<u64 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: Bound<u64>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Bound<u64>> for &'a u64

type Output = Result<Bound<<u64 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: Bound<u64>) -> Self::Output

Performs the - operation.

impl Sub<Bound<u64>> for u64

type Output = Result<Bound<<u64 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: Bound<u64>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Bound<u8>> for &'a Bound<u8>

type Output = Result<Bound<<u8 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: Bound<u8>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Bound<u8>> for &'a u8

type Output = Result<Bound<<u8 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: Bound<u8>) -> Self::Output

Performs the - operation.

impl Sub<Bound<u8>> for u8

type Output = Result<Bound<<u8 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: Bound<u8>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Bound<usize>> for &'a Bound<usize>

type Output = Result<Bound<<usize as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: Bound<usize>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Bound<usize>> for &'a usize

type Output = Result<Bound<<usize as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: Bound<usize>) -> Self::Output

Performs the - operation.

impl Sub<Bound<usize>> for usize

type Output = Result<Bound<<usize as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: Bound<usize>) -> Self::Output

Performs the - operation.

impl<'a> Sub<Duration> for &'a Bound<Duration>

type Output = Result<Bound<<Duration as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: Duration) -> Self::Output

Performs the - operation.

impl<'a> Sub<Duration> for &'a Bound<Instant>

type Output = Result<Bound<<Instant as Sub<Duration>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: Duration) -> Self::Output

Performs the - operation.

impl<'a> Sub<Duration> for &'a Bound<NaiveDateTime>

type Output = Result<Bound<<NaiveDateTime as Sub<Duration>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: Duration) -> Self::Output

Performs the - operation.

impl Sub<Duration> for Bound<Duration>

type Output = Result<Bound<<Duration as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: Duration) -> Self::Output

Performs the - operation.

impl Sub<Duration> for Bound<Instant>

type Output = Result<Bound<<Instant as Sub<Duration>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: Duration) -> Self::Output

Performs the - operation.

impl Sub<Duration> for Bound<NaiveDateTime>

type Output = Result<Bound<<NaiveDateTime as Sub<Duration>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: Duration) -> Self::Output

Performs the - operation.

impl<'a> Sub<f32> for &'a Bound<f32>

type Output = Result<Bound<<f32 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: f32) -> Self::Output

Performs the - operation.

impl Sub<f32> for Bound<f32>

type Output = Result<Bound<<f32 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: f32) -> Self::Output

Performs the - operation.

impl<'a> Sub<f64> for &'a Bound<f64>

type Output = Result<Bound<<f64 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: f64) -> Self::Output

Performs the - operation.

impl Sub<f64> for Bound<f64>

type Output = Result<Bound<<f64 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: f64) -> Self::Output

Performs the - operation.

impl<'a> Sub<i128> for &'a Bound<i128>

type Output = Result<Bound<<i128 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: i128) -> Self::Output

Performs the - operation.

impl Sub<i128> for Bound<i128>

type Output = Result<Bound<<i128 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: i128) -> Self::Output

Performs the - operation.

impl<'a> Sub<i16> for &'a Bound<i16>

type Output = Result<Bound<<i16 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: i16) -> Self::Output

Performs the - operation.

impl Sub<i16> for Bound<i16>

type Output = Result<Bound<<i16 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: i16) -> Self::Output

Performs the - operation.

impl<'a> Sub<i32> for &'a Bound<i32>

type Output = Result<Bound<<i32 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: i32) -> Self::Output

Performs the - operation.

impl Sub<i32> for Bound<i32>

type Output = Result<Bound<<i32 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: i32) -> Self::Output

Performs the - operation.

impl<'a> Sub<i64> for &'a Bound<i64>

type Output = Result<Bound<<i64 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: i64) -> Self::Output

Performs the - operation.

impl Sub<i64> for Bound<i64>

type Output = Result<Bound<<i64 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: i64) -> Self::Output

Performs the - operation.

impl<'a> Sub<i8> for &'a Bound<i8>

type Output = Result<Bound<<i8 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: i8) -> Self::Output

Performs the - operation.

impl Sub<i8> for Bound<i8>

type Output = Result<Bound<<i8 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: i8) -> Self::Output

Performs the - operation.

impl<'a> Sub<isize> for &'a Bound<isize>

type Output = Result<Bound<<isize as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: isize) -> Self::Output

Performs the - operation.

impl Sub<isize> for Bound<isize>

type Output = Result<Bound<<isize as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: isize) -> Self::Output

Performs the - operation.

impl<'a> Sub<u128> for &'a Bound<u128>

type Output = Result<Bound<<u128 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: u128) -> Self::Output

Performs the - operation.

impl Sub<u128> for Bound<u128>

type Output = Result<Bound<<u128 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: u128) -> Self::Output

Performs the - operation.

impl<'a> Sub<u16> for &'a Bound<u16>

type Output = Result<Bound<<u16 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: u16) -> Self::Output

Performs the - operation.

impl Sub<u16> for Bound<u16>

type Output = Result<Bound<<u16 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: u16) -> Self::Output

Performs the - operation.

impl<'a> Sub<u32> for &'a Bound<u32>

type Output = Result<Bound<<u32 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<u32> for Bound<u32>

type Output = Result<Bound<<u32 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'a> Sub<u64> for &'a Bound<u64>

type Output = Result<Bound<<u64 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: u64) -> Self::Output

Performs the - operation.

impl Sub<u64> for Bound<u64>

type Output = Result<Bound<<u64 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: u64) -> Self::Output

Performs the - operation.

impl<'a> Sub<u8> for &'a Bound<u8>

type Output = Result<Bound<<u8 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: u8) -> Self::Output

Performs the - operation.

impl Sub<u8> for Bound<u8>

type Output = Result<Bound<<u8 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: u8) -> Self::Output

Performs the - operation.

impl<'a> Sub<usize> for &'a Bound<usize>

type Output = Result<Bound<<usize as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: usize) -> Self::Output

Performs the - operation.

impl Sub<usize> for Bound<usize>

type Output = Result<Bound<<usize as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: usize) -> Self::Output

Performs the - operation.

impl Sub for Bound<f32>

type Output = Result<Bound<<f32 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: Bound<f32>) -> Self::Output

Performs the - operation.

impl Sub for Bound<f64>

type Output = Result<Bound<<f64 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: Bound<f64>) -> Self::Output

Performs the - operation.

impl Sub for Bound<i128>

type Output = Result<Bound<<i128 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: Bound<i128>) -> Self::Output

Performs the - operation.

impl Sub for Bound<i16>

type Output = Result<Bound<<i16 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: Bound<i16>) -> Self::Output

Performs the - operation.

impl Sub for Bound<i32>

type Output = Result<Bound<<i32 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: Bound<i32>) -> Self::Output

Performs the - operation.

impl Sub for Bound<i64>

type Output = Result<Bound<<i64 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: Bound<i64>) -> Self::Output

Performs the - operation.

impl Sub for Bound<i8>

type Output = Result<Bound<<i8 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: Bound<i8>) -> Self::Output

Performs the - operation.

impl Sub for Bound<isize>

type Output = Result<Bound<<isize as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: Bound<isize>) -> Self::Output

Performs the - operation.

impl Sub for Bound<u128>

type Output = Result<Bound<<u128 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: Bound<u128>) -> Self::Output

Performs the - operation.

impl Sub for Bound<u16>

type Output = Result<Bound<<u16 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: Bound<u16>) -> Self::Output

Performs the - operation.

impl Sub for Bound<u32>

type Output = Result<Bound<<u32 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: Bound<u32>) -> Self::Output

Performs the - operation.

impl Sub for Bound<u64>

type Output = Result<Bound<<u64 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: Bound<u64>) -> Self::Output

Performs the - operation.

impl Sub for Bound<u8>

type Output = Result<Bound<<u8 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: Bound<u8>) -> Self::Output

Performs the - operation.

impl Sub for Bound<usize>

type Output = Result<Bound<<usize as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: Bound<usize>) -> Self::Output

Performs the - operation.

impl<T: Copy> Copy for Bound<T>