Enum ValueWrapper 

#[non_exhaustive]
pub enum ValueWrapper<T> {
    Value(T),
    Inf,
    NegInf,
}

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Value(T)

Inf

NegInf

Implementations

impl<T> ValueWrapper<T>

pub fn is_inf_or_neg_inf(&self) -> bool

Trait Implementations

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = Result<ValueWrapper<<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 ValueWrapper<Instant>

type Output = Result<ValueWrapper<<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 ValueWrapper<NaiveDateTime>

type Output = Result<ValueWrapper<<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<&'b ValueWrapper<f32>> for &'a ValueWrapper<f32>

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = Result<ValueWrapper<<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 ValueWrapper<Instant>

type Output = Result<ValueWrapper<<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 ValueWrapper<NaiveDateTime>

type Output = Result<ValueWrapper<<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 ValueWrapper<Duration>

type Output = Result<ValueWrapper<<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 ValueWrapper<Instant>

type Output = Result<ValueWrapper<<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 ValueWrapper<NaiveDateTime>

type Output = Result<ValueWrapper<<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<ValueWrapper<f32>> for &'a ValueWrapper<f32>

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<ValueWrapper<f32>> for f32

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<ValueWrapper<f64>> for f64

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<ValueWrapper<i128>> for i128

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<ValueWrapper<i16>> for i16

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<ValueWrapper<i32>> for i32

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<ValueWrapper<i64>> for i64

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<ValueWrapper<i8>> for i8

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<ValueWrapper<isize>> for isize

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<ValueWrapper<u128>> for u128

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<ValueWrapper<u16>> for u16

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<ValueWrapper<u32>> for u32

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<ValueWrapper<u64>> for u64

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<ValueWrapper<u8>> for u8

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<ValueWrapper<usize>> for usize

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<f32> for ValueWrapper<f32>

type Output = Result<ValueWrapper<<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 ValueWrapper<f64>

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

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<f64> for ValueWrapper<f64>

type Output = Result<ValueWrapper<<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 ValueWrapper<i128>

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

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<i128> for ValueWrapper<i128>

type Output = Result<ValueWrapper<<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 ValueWrapper<i16>

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

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<i16> for ValueWrapper<i16>

type Output = Result<ValueWrapper<<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 ValueWrapper<i32>

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

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<i32> for ValueWrapper<i32>

type Output = Result<ValueWrapper<<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 ValueWrapper<i64>

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

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<i64> for ValueWrapper<i64>

type Output = Result<ValueWrapper<<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 ValueWrapper<i8>

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

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<i8> for ValueWrapper<i8>

type Output = Result<ValueWrapper<<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 ValueWrapper<isize>

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

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<isize> for ValueWrapper<isize>

type Output = Result<ValueWrapper<<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 ValueWrapper<u128>

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

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<u128> for ValueWrapper<u128>

type Output = Result<ValueWrapper<<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 ValueWrapper<u16>

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

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<u16> for ValueWrapper<u16>

type Output = Result<ValueWrapper<<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 ValueWrapper<u32>

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

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<u32> for ValueWrapper<u32>

type Output = Result<ValueWrapper<<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 ValueWrapper<u64>

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

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<u64> for ValueWrapper<u64>

type Output = Result<ValueWrapper<<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 ValueWrapper<u8>

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

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<u8> for ValueWrapper<u8>

type Output = Result<ValueWrapper<<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 ValueWrapper<usize>

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

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<usize> for ValueWrapper<usize>

type Output = Result<ValueWrapper<<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 ValueWrapper<f32>

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

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add for ValueWrapper<f64>

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

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add for ValueWrapper<i128>

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

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add for ValueWrapper<i16>

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

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add for ValueWrapper<i32>

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

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add for ValueWrapper<i64>

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

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add for ValueWrapper<i8>

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

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add for ValueWrapper<isize>

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

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add for ValueWrapper<u128>

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

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add for ValueWrapper<u16>

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

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add for ValueWrapper<u32>

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

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add for ValueWrapper<u64>

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

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add for ValueWrapper<u8>

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

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add for ValueWrapper<usize>

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

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T: Clone> Clone for ValueWrapper<T>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Display> Debug for ValueWrapper<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: Display> Display for ValueWrapper<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

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

type Output = Result<ValueWrapper<<&'a f32 as Div<&'b f32>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<ValueWrapper<<f32 as Div<&'b f32>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<ValueWrapper<<f32 as Div<&'a f32>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<ValueWrapper<<f32 as Div<&'a f32>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<ValueWrapper<<&'a f64 as Div<&'b f64>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<ValueWrapper<<f64 as Div<&'b f64>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<ValueWrapper<<f64 as Div<&'a f64>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<ValueWrapper<<f64 as Div<&'a f64>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<ValueWrapper<<&'a i128 as Div<&'b i128>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<ValueWrapper<<i128 as Div<&'b i128>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<ValueWrapper<<i128 as Div<&'a i128>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<ValueWrapper<<i128 as Div<&'a i128>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<ValueWrapper<<&'a i16 as Div<&'b i16>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<ValueWrapper<<i16 as Div<&'b i16>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<ValueWrapper<<i16 as Div<&'a i16>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<ValueWrapper<<i16 as Div<&'a i16>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<ValueWrapper<<&'a i32 as Div<&'b i32>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<ValueWrapper<<i32 as Div<&'b i32>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<ValueWrapper<<i32 as Div<&'a i32>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<ValueWrapper<<i32 as Div<&'a i32>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<ValueWrapper<<&'a i64 as Div<&'b i64>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<ValueWrapper<<i64 as Div<&'b i64>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<ValueWrapper<<i64 as Div<&'a i64>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<ValueWrapper<<i64 as Div<&'a i64>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<ValueWrapper<<&'a i8 as Div<&'b i8>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<ValueWrapper<<i8 as Div<&'b i8>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<ValueWrapper<<i8 as Div<&'a i8>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<ValueWrapper<<i8 as Div<&'a i8>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<ValueWrapper<<&'a isize as Div<&'b isize>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<ValueWrapper<<isize as Div<&'b isize>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<ValueWrapper<<isize as Div<&'a isize>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<ValueWrapper<<isize as Div<&'a isize>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<ValueWrapper<<&'a u128 as Div<&'b u128>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<ValueWrapper<<u128 as Div<&'b u128>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<ValueWrapper<<u128 as Div<&'a u128>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<ValueWrapper<<u128 as Div<&'a u128>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<ValueWrapper<<&'a u16 as Div<&'b u16>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<ValueWrapper<<u16 as Div<&'b u16>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<ValueWrapper<<u16 as Div<&'a u16>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<ValueWrapper<<u16 as Div<&'a u16>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<ValueWrapper<<&'a u32 as Div<&'b u32>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<ValueWrapper<<u32 as Div<&'b u32>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<ValueWrapper<<u32 as Div<&'a u32>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<ValueWrapper<<u32 as Div<&'a u32>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<ValueWrapper<<&'a u64 as Div<&'b u64>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<ValueWrapper<<u64 as Div<&'b u64>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<ValueWrapper<<u64 as Div<&'a u64>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<ValueWrapper<<u64 as Div<&'a u64>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<ValueWrapper<<&'a u8 as Div<&'b u8>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<ValueWrapper<<u8 as Div<&'b u8>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<ValueWrapper<<u8 as Div<&'a u8>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<ValueWrapper<<u8 as Div<&'a u8>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<ValueWrapper<<&'a usize as Div<&'b usize>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<ValueWrapper<<usize as Div<&'b usize>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<ValueWrapper<<usize as Div<&'a usize>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<ValueWrapper<<usize as Div<&'a usize>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<ValueWrapper<<&'a f32 as Div<&'b f32>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<ValueWrapper<<f32 as Div<&'a f32>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<ValueWrapper<<&'a f64 as Div<&'b f64>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<ValueWrapper<<f64 as Div<&'a f64>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<ValueWrapper<<&'a i128 as Div<&'b i128>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<ValueWrapper<<i128 as Div<&'a i128>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<ValueWrapper<<&'a i16 as Div<&'b i16>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<ValueWrapper<<i16 as Div<&'a i16>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<ValueWrapper<<&'a i32 as Div<&'b i32>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<ValueWrapper<<i32 as Div<&'a i32>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<ValueWrapper<<&'a i64 as Div<&'b i64>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<ValueWrapper<<i64 as Div<&'a i64>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<ValueWrapper<<&'a i8 as Div<&'b i8>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<ValueWrapper<<i8 as Div<&'a i8>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<ValueWrapper<<&'a isize as Div<&'b isize>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<ValueWrapper<<isize as Div<&'a isize>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<ValueWrapper<<&'a u128 as Div<&'b u128>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<ValueWrapper<<u128 as Div<&'a u128>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<ValueWrapper<<&'a u16 as Div<&'b u16>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<ValueWrapper<<u16 as Div<&'a u16>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<ValueWrapper<<&'a u32 as Div<&'b u32>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<ValueWrapper<<u32 as Div<&'a u32>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<ValueWrapper<<&'a u64 as Div<&'b u64>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<ValueWrapper<<u64 as Div<&'a u64>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<ValueWrapper<<&'a u8 as Div<&'b u8>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<ValueWrapper<<u8 as Div<&'a u8>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<ValueWrapper<<&'a usize as Div<&'b usize>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<ValueWrapper<<usize as Div<&'a usize>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<ValueWrapper<<&'a f32 as Div<f32>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

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

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<ValueWrapper<f32>> for f32

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

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<ValueWrapper<<&'a f64 as Div<f64>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

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

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<ValueWrapper<f64>> for f64

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

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<ValueWrapper<<&'a i128 as Div<i128>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

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

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<ValueWrapper<i128>> for i128

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

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<ValueWrapper<<&'a i16 as Div<i16>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

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

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<ValueWrapper<i16>> for i16

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

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<ValueWrapper<<&'a i32 as Div<i32>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

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

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<ValueWrapper<i32>> for i32

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

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<ValueWrapper<<&'a i64 as Div<i64>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

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

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<ValueWrapper<i64>> for i64

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

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<ValueWrapper<<&'a i8 as Div<i8>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: ValueWrapper<i8>) -> Self::Output

Performs the / operation.

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

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

The resulting type after applying the / operator.

fn div(self, rhs: ValueWrapper<i8>) -> Self::Output

Performs the / operation.

impl Div<ValueWrapper<i8>> for i8

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

The resulting type after applying the / operator.

fn div(self, rhs: ValueWrapper<i8>) -> Self::Output

Performs the / operation.

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

type Output = Result<ValueWrapper<<&'a isize as Div<isize>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: ValueWrapper<isize>) -> Self::Output

Performs the / operation.

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

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

The resulting type after applying the / operator.

fn div(self, rhs: ValueWrapper<isize>) -> Self::Output

Performs the / operation.

impl Div<ValueWrapper<isize>> for isize

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

The resulting type after applying the / operator.

fn div(self, rhs: ValueWrapper<isize>) -> Self::Output

Performs the / operation.

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

type Output = Result<ValueWrapper<<&'a u128 as Div<u128>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: ValueWrapper<u128>) -> Self::Output

Performs the / operation.

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

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

The resulting type after applying the / operator.

fn div(self, rhs: ValueWrapper<u128>) -> Self::Output

Performs the / operation.

impl Div<ValueWrapper<u128>> for u128

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

The resulting type after applying the / operator.

fn div(self, rhs: ValueWrapper<u128>) -> Self::Output

Performs the / operation.

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

type Output = Result<ValueWrapper<<&'a u16 as Div<u16>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: ValueWrapper<u16>) -> Self::Output

Performs the / operation.

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

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

The resulting type after applying the / operator.

fn div(self, rhs: ValueWrapper<u16>) -> Self::Output

Performs the / operation.

impl Div<ValueWrapper<u16>> for u16

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

The resulting type after applying the / operator.

fn div(self, rhs: ValueWrapper<u16>) -> Self::Output

Performs the / operation.

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

type Output = Result<ValueWrapper<<&'a u32 as Div<u32>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: ValueWrapper<u32>) -> Self::Output

Performs the / operation.

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

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

The resulting type after applying the / operator.

fn div(self, rhs: ValueWrapper<u32>) -> Self::Output

Performs the / operation.

impl Div<ValueWrapper<u32>> for u32

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

The resulting type after applying the / operator.

fn div(self, rhs: ValueWrapper<u32>) -> Self::Output

Performs the / operation.

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

type Output = Result<ValueWrapper<<&'a u64 as Div<u64>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: ValueWrapper<u64>) -> Self::Output

Performs the / operation.

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

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

The resulting type after applying the / operator.

fn div(self, rhs: ValueWrapper<u64>) -> Self::Output

Performs the / operation.

impl Div<ValueWrapper<u64>> for u64

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

The resulting type after applying the / operator.

fn div(self, rhs: ValueWrapper<u64>) -> Self::Output

Performs the / operation.

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

type Output = Result<ValueWrapper<<&'a u8 as Div<u8>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: ValueWrapper<u8>) -> Self::Output

Performs the / operation.

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

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

The resulting type after applying the / operator.

fn div(self, rhs: ValueWrapper<u8>) -> Self::Output

Performs the / operation.

impl Div<ValueWrapper<u8>> for u8

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

The resulting type after applying the / operator.

fn div(self, rhs: ValueWrapper<u8>) -> Self::Output

Performs the / operation.

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

type Output = Result<ValueWrapper<<&'a usize as Div<usize>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

fn div(self, rhs: ValueWrapper<usize>) -> Self::Output

Performs the / operation.

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

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

The resulting type after applying the / operator.

fn div(self, rhs: ValueWrapper<usize>) -> Self::Output

Performs the / operation.

impl Div<ValueWrapper<usize>> for usize

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

The resulting type after applying the / operator.

fn div(self, rhs: ValueWrapper<usize>) -> Self::Output

Performs the / operation.

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

type Output = Result<ValueWrapper<<&'a f32 as Div<f32>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<f32> for ValueWrapper<f32>

type Output = Result<ValueWrapper<<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 ValueWrapper<f64>

type Output = Result<ValueWrapper<<&'a f64 as Div<f64>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<f64> for ValueWrapper<f64>

type Output = Result<ValueWrapper<<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 ValueWrapper<i128>

type Output = Result<ValueWrapper<<&'a i128 as Div<i128>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<i128> for ValueWrapper<i128>

type Output = Result<ValueWrapper<<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 ValueWrapper<i16>

type Output = Result<ValueWrapper<<&'a i16 as Div<i16>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<i16> for ValueWrapper<i16>

type Output = Result<ValueWrapper<<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 ValueWrapper<i32>

type Output = Result<ValueWrapper<<&'a i32 as Div<i32>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<i32> for ValueWrapper<i32>

type Output = Result<ValueWrapper<<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 ValueWrapper<i64>

type Output = Result<ValueWrapper<<&'a i64 as Div<i64>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<i64> for ValueWrapper<i64>

type Output = Result<ValueWrapper<<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 ValueWrapper<i8>

type Output = Result<ValueWrapper<<&'a i8 as Div<i8>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<i8> for ValueWrapper<i8>

type Output = Result<ValueWrapper<<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 ValueWrapper<isize>

type Output = Result<ValueWrapper<<&'a isize as Div<isize>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<isize> for ValueWrapper<isize>

type Output = Result<ValueWrapper<<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 ValueWrapper<u128>

type Output = Result<ValueWrapper<<&'a u128 as Div<u128>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<u128> for ValueWrapper<u128>

type Output = Result<ValueWrapper<<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 ValueWrapper<u16>

type Output = Result<ValueWrapper<<&'a u16 as Div<u16>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<u16> for ValueWrapper<u16>

type Output = Result<ValueWrapper<<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 ValueWrapper<u32>

type Output = Result<ValueWrapper<<&'a u32 as Div<u32>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<u32> for ValueWrapper<u32>

type Output = Result<ValueWrapper<<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 ValueWrapper<u64>

type Output = Result<ValueWrapper<<&'a u64 as Div<u64>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<u64> for ValueWrapper<u64>

type Output = Result<ValueWrapper<<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 ValueWrapper<u8>

type Output = Result<ValueWrapper<<&'a u8 as Div<u8>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<u8> for ValueWrapper<u8>

type Output = Result<ValueWrapper<<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 ValueWrapper<usize>

type Output = Result<ValueWrapper<<&'a usize as Div<usize>>::Output>, IllegalArgumentError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<usize> for ValueWrapper<usize>

type Output = Result<ValueWrapper<<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 ValueWrapper<f32>

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

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div for ValueWrapper<f64>

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

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div for ValueWrapper<i128>

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

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div for ValueWrapper<i16>

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

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div for ValueWrapper<i32>

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

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div for ValueWrapper<i64>

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

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div for ValueWrapper<i8>

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

The resulting type after applying the / operator.

fn div(self, rhs: ValueWrapper<i8>) -> Self::Output

Performs the / operation.

impl Div for ValueWrapper<isize>

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

The resulting type after applying the / operator.

fn div(self, rhs: ValueWrapper<isize>) -> Self::Output

Performs the / operation.

impl Div for ValueWrapper<u128>

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

The resulting type after applying the / operator.

fn div(self, rhs: ValueWrapper<u128>) -> Self::Output

Performs the / operation.

impl Div for ValueWrapper<u16>

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

The resulting type after applying the / operator.

fn div(self, rhs: ValueWrapper<u16>) -> Self::Output

Performs the / operation.

impl Div for ValueWrapper<u32>

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

The resulting type after applying the / operator.

fn div(self, rhs: ValueWrapper<u32>) -> Self::Output

Performs the / operation.

impl Div for ValueWrapper<u64>

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

The resulting type after applying the / operator.

fn div(self, rhs: ValueWrapper<u64>) -> Self::Output

Performs the / operation.

impl Div for ValueWrapper<u8>

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

The resulting type after applying the / operator.

fn div(self, rhs: ValueWrapper<u8>) -> Self::Output

Performs the / operation.

impl Div for ValueWrapper<usize>

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

The resulting type after applying the / operator.

fn div(self, rhs: ValueWrapper<usize>) -> Self::Output

Performs the / operation.

impl<'a> From<&'a Duration> for ValueWrapper<Duration>

fn from(value: &'a Duration) -> Self

Converts to this type from the input type.

impl<'a> From<&'a Instant> for ValueWrapper<Instant>

fn from(value: &'a Instant) -> Self

Converts to this type from the input type.

impl<'a> From<&'a NaiveDateTime> for ValueWrapper<NaiveDateTime>

fn from(value: &'a NaiveDateTime) -> Self

Converts to this type from the input type.

impl<T: for<'a> From<&'a U>, U> From<&ValueWrapper<U>> for ValueWrapper<T>

fn from(value: &ValueWrapper<U>) -> Self

Converts to this type from the input type.

impl From<Duration> for ValueWrapper<Duration>

fn from(value: Duration) -> Self

Converts to this type from the input type.

impl<T> From<Infinity> for ValueWrapper<T>

fn from(_: Infinity) -> Self

Converts to this type from the input type.

impl From<Instant> for ValueWrapper<Instant>

fn from(value: Instant) -> Self

Converts to this type from the input type.

impl From<NaiveDateTime> for ValueWrapper<NaiveDateTime>

fn from(value: NaiveDateTime) -> Self

Converts to this type from the input type.

impl<T> From<NegativeInfinity> for ValueWrapper<T>

fn from(_: NegativeInfinity) -> Self

Converts to this type from the input type.

impl<T: SemiArithmetic> From<T> for ValueWrapper<T>

default fn from(value: T) -> Self

Converts to this type from the input type.

impl<T: RealNumber> From<T> for ValueWrapper<T>

fn from(value: T) -> Self

Converts to this type from the input type.

impl<'a, 'b> Mul<&'b ValueWrapper<f32>> for &'a ValueWrapper<f32>

type Output = Result<ValueWrapper<<&'a f32 as Mul<&'b f32>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, 'b> Mul<&'b ValueWrapper<f32>> for &'a f32

type Output = Result<ValueWrapper<<&'a f32 as Mul<&'b f32>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a> Mul<&'a ValueWrapper<f32>> for ValueWrapper<f32>

type Output = Result<ValueWrapper<<f32 as Mul<&'a f32>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a> Mul<&'a ValueWrapper<f32>> for f32

type Output = Result<ValueWrapper<<f32 as Mul<&'a f32>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, 'b> Mul<&'b ValueWrapper<f64>> for &'a ValueWrapper<f64>

type Output = Result<ValueWrapper<<&'a f64 as Mul<&'b f64>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, 'b> Mul<&'b ValueWrapper<f64>> for &'a f64

type Output = Result<ValueWrapper<<&'a f64 as Mul<&'b f64>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a> Mul<&'a ValueWrapper<f64>> for ValueWrapper<f64>

type Output = Result<ValueWrapper<<f64 as Mul<&'a f64>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a> Mul<&'a ValueWrapper<f64>> for f64

type Output = Result<ValueWrapper<<f64 as Mul<&'a f64>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, 'b> Mul<&'b ValueWrapper<i128>> for &'a ValueWrapper<i128>

type Output = Result<ValueWrapper<<&'a i128 as Mul<&'b i128>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, 'b> Mul<&'b ValueWrapper<i128>> for &'a i128

type Output = Result<ValueWrapper<<&'a i128 as Mul<&'b i128>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a> Mul<&'a ValueWrapper<i128>> for ValueWrapper<i128>

type Output = Result<ValueWrapper<<i128 as Mul<&'a i128>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a> Mul<&'a ValueWrapper<i128>> for i128

type Output = Result<ValueWrapper<<i128 as Mul<&'a i128>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, 'b> Mul<&'b ValueWrapper<i16>> for &'a ValueWrapper<i16>

type Output = Result<ValueWrapper<<&'a i16 as Mul<&'b i16>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, 'b> Mul<&'b ValueWrapper<i16>> for &'a i16

type Output = Result<ValueWrapper<<&'a i16 as Mul<&'b i16>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a> Mul<&'a ValueWrapper<i16>> for ValueWrapper<i16>

type Output = Result<ValueWrapper<<i16 as Mul<&'a i16>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a> Mul<&'a ValueWrapper<i16>> for i16

type Output = Result<ValueWrapper<<i16 as Mul<&'a i16>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, 'b> Mul<&'b ValueWrapper<i32>> for &'a ValueWrapper<i32>

type Output = Result<ValueWrapper<<&'a i32 as Mul<&'b i32>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, 'b> Mul<&'b ValueWrapper<i32>> for &'a i32

type Output = Result<ValueWrapper<<&'a i32 as Mul<&'b i32>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a> Mul<&'a ValueWrapper<i32>> for ValueWrapper<i32>

type Output = Result<ValueWrapper<<i32 as Mul<&'a i32>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a> Mul<&'a ValueWrapper<i32>> for i32

type Output = Result<ValueWrapper<<i32 as Mul<&'a i32>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, 'b> Mul<&'b ValueWrapper<i64>> for &'a ValueWrapper<i64>

type Output = Result<ValueWrapper<<&'a i64 as Mul<&'b i64>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, 'b> Mul<&'b ValueWrapper<i64>> for &'a i64

type Output = Result<ValueWrapper<<&'a i64 as Mul<&'b i64>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a> Mul<&'a ValueWrapper<i64>> for ValueWrapper<i64>

type Output = Result<ValueWrapper<<i64 as Mul<&'a i64>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a> Mul<&'a ValueWrapper<i64>> for i64

type Output = Result<ValueWrapper<<i64 as Mul<&'a i64>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, 'b> Mul<&'b ValueWrapper<i8>> for &'a ValueWrapper<i8>

type Output = Result<ValueWrapper<<&'a i8 as Mul<&'b i8>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, 'b> Mul<&'b ValueWrapper<i8>> for &'a i8

type Output = Result<ValueWrapper<<&'a i8 as Mul<&'b i8>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a> Mul<&'a ValueWrapper<i8>> for ValueWrapper<i8>

type Output = Result<ValueWrapper<<i8 as Mul<&'a i8>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a> Mul<&'a ValueWrapper<i8>> for i8

type Output = Result<ValueWrapper<<i8 as Mul<&'a i8>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, 'b> Mul<&'b ValueWrapper<isize>> for &'a ValueWrapper<isize>

type Output = Result<ValueWrapper<<&'a isize as Mul<&'b isize>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, 'b> Mul<&'b ValueWrapper<isize>> for &'a isize

type Output = Result<ValueWrapper<<&'a isize as Mul<&'b isize>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a> Mul<&'a ValueWrapper<isize>> for ValueWrapper<isize>

type Output = Result<ValueWrapper<<isize as Mul<&'a isize>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a> Mul<&'a ValueWrapper<isize>> for isize

type Output = Result<ValueWrapper<<isize as Mul<&'a isize>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, 'b> Mul<&'b ValueWrapper<u128>> for &'a ValueWrapper<u128>

type Output = Result<ValueWrapper<<&'a u128 as Mul<&'b u128>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, 'b> Mul<&'b ValueWrapper<u128>> for &'a u128

type Output = Result<ValueWrapper<<&'a u128 as Mul<&'b u128>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a> Mul<&'a ValueWrapper<u128>> for ValueWrapper<u128>

type Output = Result<ValueWrapper<<u128 as Mul<&'a u128>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a> Mul<&'a ValueWrapper<u128>> for u128

type Output = Result<ValueWrapper<<u128 as Mul<&'a u128>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, 'b> Mul<&'b ValueWrapper<u16>> for &'a ValueWrapper<u16>

type Output = Result<ValueWrapper<<&'a u16 as Mul<&'b u16>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, 'b> Mul<&'b ValueWrapper<u16>> for &'a u16

type Output = Result<ValueWrapper<<&'a u16 as Mul<&'b u16>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a> Mul<&'a ValueWrapper<u16>> for ValueWrapper<u16>

type Output = Result<ValueWrapper<<u16 as Mul<&'a u16>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a> Mul<&'a ValueWrapper<u16>> for u16

type Output = Result<ValueWrapper<<u16 as Mul<&'a u16>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, 'b> Mul<&'b ValueWrapper<u32>> for &'a ValueWrapper<u32>

type Output = Result<ValueWrapper<<&'a u32 as Mul<&'b u32>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, 'b> Mul<&'b ValueWrapper<u32>> for &'a u32

type Output = Result<ValueWrapper<<&'a u32 as Mul<&'b u32>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a> Mul<&'a ValueWrapper<u32>> for ValueWrapper<u32>

type Output = Result<ValueWrapper<<u32 as Mul<&'a u32>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a> Mul<&'a ValueWrapper<u32>> for u32

type Output = Result<ValueWrapper<<u32 as Mul<&'a u32>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, 'b> Mul<&'b ValueWrapper<u64>> for &'a ValueWrapper<u64>

type Output = Result<ValueWrapper<<&'a u64 as Mul<&'b u64>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, 'b> Mul<&'b ValueWrapper<u64>> for &'a u64

type Output = Result<ValueWrapper<<&'a u64 as Mul<&'b u64>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a> Mul<&'a ValueWrapper<u64>> for ValueWrapper<u64>

type Output = Result<ValueWrapper<<u64 as Mul<&'a u64>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a> Mul<&'a ValueWrapper<u64>> for u64

type Output = Result<ValueWrapper<<u64 as Mul<&'a u64>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, 'b> Mul<&'b ValueWrapper<u8>> for &'a ValueWrapper<u8>

type Output = Result<ValueWrapper<<&'a u8 as Mul<&'b u8>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, 'b> Mul<&'b ValueWrapper<u8>> for &'a u8

type Output = Result<ValueWrapper<<&'a u8 as Mul<&'b u8>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a> Mul<&'a ValueWrapper<u8>> for ValueWrapper<u8>

type Output = Result<ValueWrapper<<u8 as Mul<&'a u8>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a> Mul<&'a ValueWrapper<u8>> for u8

type Output = Result<ValueWrapper<<u8 as Mul<&'a u8>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, 'b> Mul<&'b ValueWrapper<usize>> for &'a ValueWrapper<usize>

type Output = Result<ValueWrapper<<&'a usize as Mul<&'b usize>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, 'b> Mul<&'b ValueWrapper<usize>> for &'a usize

type Output = Result<ValueWrapper<<&'a usize as Mul<&'b usize>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a> Mul<&'a ValueWrapper<usize>> for ValueWrapper<usize>

type Output = Result<ValueWrapper<<usize as Mul<&'a usize>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a> Mul<&'a ValueWrapper<usize>> for usize

type Output = Result<ValueWrapper<<usize as Mul<&'a usize>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, 'b> Mul<&'b f32> for &'a ValueWrapper<f32>

type Output = Result<ValueWrapper<<&'a f32 as Mul<&'b f32>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b f32) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a f32> for ValueWrapper<f32>

type Output = Result<ValueWrapper<<f32 as Mul<&'a f32>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, 'b> Mul<&'b f64> for &'a ValueWrapper<f64>

type Output = Result<ValueWrapper<<&'a f64 as Mul<&'b f64>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b f64) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a f64> for ValueWrapper<f64>

type Output = Result<ValueWrapper<<f64 as Mul<&'a f64>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, 'b> Mul<&'b i128> for &'a ValueWrapper<i128>

type Output = Result<ValueWrapper<<&'a i128 as Mul<&'b i128>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b i128) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a i128> for ValueWrapper<i128>

type Output = Result<ValueWrapper<<i128 as Mul<&'a i128>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, 'b> Mul<&'b i16> for &'a ValueWrapper<i16>

type Output = Result<ValueWrapper<<&'a i16 as Mul<&'b i16>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b i16) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a i16> for ValueWrapper<i16>

type Output = Result<ValueWrapper<<i16 as Mul<&'a i16>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, 'b> Mul<&'b i32> for &'a ValueWrapper<i32>

type Output = Result<ValueWrapper<<&'a i32 as Mul<&'b i32>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b i32) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a i32> for ValueWrapper<i32>

type Output = Result<ValueWrapper<<i32 as Mul<&'a i32>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, 'b> Mul<&'b i64> for &'a ValueWrapper<i64>

type Output = Result<ValueWrapper<<&'a i64 as Mul<&'b i64>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b i64) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a i64> for ValueWrapper<i64>

type Output = Result<ValueWrapper<<i64 as Mul<&'a i64>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, 'b> Mul<&'b i8> for &'a ValueWrapper<i8>

type Output = Result<ValueWrapper<<&'a i8 as Mul<&'b i8>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b i8) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a i8> for ValueWrapper<i8>

type Output = Result<ValueWrapper<<i8 as Mul<&'a i8>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, 'b> Mul<&'b isize> for &'a ValueWrapper<isize>

type Output = Result<ValueWrapper<<&'a isize as Mul<&'b isize>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b isize) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a isize> for ValueWrapper<isize>

type Output = Result<ValueWrapper<<isize as Mul<&'a isize>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, 'b> Mul<&'b u128> for &'a ValueWrapper<u128>

type Output = Result<ValueWrapper<<&'a u128 as Mul<&'b u128>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b u128) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a u128> for ValueWrapper<u128>

type Output = Result<ValueWrapper<<u128 as Mul<&'a u128>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, 'b> Mul<&'b u16> for &'a ValueWrapper<u16>

type Output = Result<ValueWrapper<<&'a u16 as Mul<&'b u16>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b u16) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a u16> for ValueWrapper<u16>

type Output = Result<ValueWrapper<<u16 as Mul<&'a u16>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, 'b> Mul<&'b u32> for &'a ValueWrapper<u32>

type Output = Result<ValueWrapper<<&'a u32 as Mul<&'b u32>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b u32) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a u32> for ValueWrapper<u32>

type Output = Result<ValueWrapper<<u32 as Mul<&'a u32>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, 'b> Mul<&'b u64> for &'a ValueWrapper<u64>

type Output = Result<ValueWrapper<<&'a u64 as Mul<&'b u64>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b u64) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a u64> for ValueWrapper<u64>

type Output = Result<ValueWrapper<<u64 as Mul<&'a u64>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, 'b> Mul<&'b u8> for &'a ValueWrapper<u8>

type Output = Result<ValueWrapper<<&'a u8 as Mul<&'b u8>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b u8) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a u8> for ValueWrapper<u8>

type Output = Result<ValueWrapper<<u8 as Mul<&'a u8>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, 'b> Mul<&'b usize> for &'a ValueWrapper<usize>

type Output = Result<ValueWrapper<<&'a usize as Mul<&'b usize>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b usize) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a usize> for ValueWrapper<usize>

type Output = Result<ValueWrapper<<usize as Mul<&'a usize>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a> Mul<ValueWrapper<f32>> for &'a ValueWrapper<f32>

type Output = Result<ValueWrapper<<f32 as Mul<&'a f32>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: ValueWrapper<f32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<ValueWrapper<f32>> for &'a f32

type Output = Result<ValueWrapper<<f32 as Mul<&'a f32>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: ValueWrapper<f32>) -> Self::Output

Performs the * operation.

impl Mul<ValueWrapper<f32>> for f32

type Output = Result<ValueWrapper<<f32 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: ValueWrapper<f32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<ValueWrapper<f64>> for &'a ValueWrapper<f64>

type Output = Result<ValueWrapper<<f64 as Mul<&'a f64>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: ValueWrapper<f64>) -> Self::Output

Performs the * operation.

impl<'a> Mul<ValueWrapper<f64>> for &'a f64

type Output = Result<ValueWrapper<<f64 as Mul<&'a f64>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: ValueWrapper<f64>) -> Self::Output

Performs the * operation.

impl Mul<ValueWrapper<f64>> for f64

type Output = Result<ValueWrapper<<f64 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: ValueWrapper<f64>) -> Self::Output

Performs the * operation.

impl<'a> Mul<ValueWrapper<i128>> for &'a ValueWrapper<i128>

type Output = Result<ValueWrapper<<i128 as Mul<&'a i128>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: ValueWrapper<i128>) -> Self::Output

Performs the * operation.

impl<'a> Mul<ValueWrapper<i128>> for &'a i128

type Output = Result<ValueWrapper<<i128 as Mul<&'a i128>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: ValueWrapper<i128>) -> Self::Output

Performs the * operation.

impl Mul<ValueWrapper<i128>> for i128

type Output = Result<ValueWrapper<<i128 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: ValueWrapper<i128>) -> Self::Output

Performs the * operation.

impl<'a> Mul<ValueWrapper<i16>> for &'a ValueWrapper<i16>

type Output = Result<ValueWrapper<<i16 as Mul<&'a i16>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: ValueWrapper<i16>) -> Self::Output

Performs the * operation.

impl<'a> Mul<ValueWrapper<i16>> for &'a i16

type Output = Result<ValueWrapper<<i16 as Mul<&'a i16>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: ValueWrapper<i16>) -> Self::Output

Performs the * operation.

impl Mul<ValueWrapper<i16>> for i16

type Output = Result<ValueWrapper<<i16 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: ValueWrapper<i16>) -> Self::Output

Performs the * operation.

impl<'a> Mul<ValueWrapper<i32>> for &'a ValueWrapper<i32>

type Output = Result<ValueWrapper<<i32 as Mul<&'a i32>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: ValueWrapper<i32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<ValueWrapper<i32>> for &'a i32

type Output = Result<ValueWrapper<<i32 as Mul<&'a i32>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: ValueWrapper<i32>) -> Self::Output

Performs the * operation.

impl Mul<ValueWrapper<i32>> for i32

type Output = Result<ValueWrapper<<i32 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: ValueWrapper<i32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<ValueWrapper<i64>> for &'a ValueWrapper<i64>

type Output = Result<ValueWrapper<<i64 as Mul<&'a i64>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: ValueWrapper<i64>) -> Self::Output

Performs the * operation.

impl<'a> Mul<ValueWrapper<i64>> for &'a i64

type Output = Result<ValueWrapper<<i64 as Mul<&'a i64>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: ValueWrapper<i64>) -> Self::Output

Performs the * operation.

impl Mul<ValueWrapper<i64>> for i64

type Output = Result<ValueWrapper<<i64 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: ValueWrapper<i64>) -> Self::Output

Performs the * operation.

impl<'a> Mul<ValueWrapper<i8>> for &'a ValueWrapper<i8>

type Output = Result<ValueWrapper<<i8 as Mul<&'a i8>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: ValueWrapper<i8>) -> Self::Output

Performs the * operation.

impl<'a> Mul<ValueWrapper<i8>> for &'a i8

type Output = Result<ValueWrapper<<i8 as Mul<&'a i8>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: ValueWrapper<i8>) -> Self::Output

Performs the * operation.

impl Mul<ValueWrapper<i8>> for i8

type Output = Result<ValueWrapper<<i8 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: ValueWrapper<i8>) -> Self::Output

Performs the * operation.

impl<'a> Mul<ValueWrapper<isize>> for &'a ValueWrapper<isize>

type Output = Result<ValueWrapper<<isize as Mul<&'a isize>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: ValueWrapper<isize>) -> Self::Output

Performs the * operation.

impl<'a> Mul<ValueWrapper<isize>> for &'a isize

type Output = Result<ValueWrapper<<isize as Mul<&'a isize>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: ValueWrapper<isize>) -> Self::Output

Performs the * operation.

impl Mul<ValueWrapper<isize>> for isize

type Output = Result<ValueWrapper<<isize as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: ValueWrapper<isize>) -> Self::Output

Performs the * operation.

impl<'a> Mul<ValueWrapper<u128>> for &'a ValueWrapper<u128>

type Output = Result<ValueWrapper<<u128 as Mul<&'a u128>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: ValueWrapper<u128>) -> Self::Output

Performs the * operation.

impl<'a> Mul<ValueWrapper<u128>> for &'a u128

type Output = Result<ValueWrapper<<u128 as Mul<&'a u128>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: ValueWrapper<u128>) -> Self::Output

Performs the * operation.

impl Mul<ValueWrapper<u128>> for u128

type Output = Result<ValueWrapper<<u128 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: ValueWrapper<u128>) -> Self::Output

Performs the * operation.

impl<'a> Mul<ValueWrapper<u16>> for &'a ValueWrapper<u16>

type Output = Result<ValueWrapper<<u16 as Mul<&'a u16>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: ValueWrapper<u16>) -> Self::Output

Performs the * operation.

impl<'a> Mul<ValueWrapper<u16>> for &'a u16

type Output = Result<ValueWrapper<<u16 as Mul<&'a u16>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: ValueWrapper<u16>) -> Self::Output

Performs the * operation.

impl Mul<ValueWrapper<u16>> for u16

type Output = Result<ValueWrapper<<u16 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: ValueWrapper<u16>) -> Self::Output

Performs the * operation.

impl<'a> Mul<ValueWrapper<u32>> for &'a ValueWrapper<u32>

type Output = Result<ValueWrapper<<u32 as Mul<&'a u32>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: ValueWrapper<u32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<ValueWrapper<u32>> for &'a u32

type Output = Result<ValueWrapper<<u32 as Mul<&'a u32>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: ValueWrapper<u32>) -> Self::Output

Performs the * operation.

impl Mul<ValueWrapper<u32>> for u32

type Output = Result<ValueWrapper<<u32 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: ValueWrapper<u32>) -> Self::Output

Performs the * operation.

impl<'a> Mul<ValueWrapper<u64>> for &'a ValueWrapper<u64>

type Output = Result<ValueWrapper<<u64 as Mul<&'a u64>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: ValueWrapper<u64>) -> Self::Output

Performs the * operation.

impl<'a> Mul<ValueWrapper<u64>> for &'a u64

type Output = Result<ValueWrapper<<u64 as Mul<&'a u64>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: ValueWrapper<u64>) -> Self::Output

Performs the * operation.

impl Mul<ValueWrapper<u64>> for u64

type Output = Result<ValueWrapper<<u64 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: ValueWrapper<u64>) -> Self::Output

Performs the * operation.

impl<'a> Mul<ValueWrapper<u8>> for &'a ValueWrapper<u8>

type Output = Result<ValueWrapper<<u8 as Mul<&'a u8>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: ValueWrapper<u8>) -> Self::Output

Performs the * operation.

impl<'a> Mul<ValueWrapper<u8>> for &'a u8

type Output = Result<ValueWrapper<<u8 as Mul<&'a u8>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: ValueWrapper<u8>) -> Self::Output

Performs the * operation.

impl Mul<ValueWrapper<u8>> for u8

type Output = Result<ValueWrapper<<u8 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: ValueWrapper<u8>) -> Self::Output

Performs the * operation.

impl<'a> Mul<ValueWrapper<usize>> for &'a ValueWrapper<usize>

type Output = Result<ValueWrapper<<usize as Mul<&'a usize>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: ValueWrapper<usize>) -> Self::Output

Performs the * operation.

impl<'a> Mul<ValueWrapper<usize>> for &'a usize

type Output = Result<ValueWrapper<<usize as Mul<&'a usize>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: ValueWrapper<usize>) -> Self::Output

Performs the * operation.

impl Mul<ValueWrapper<usize>> for usize

type Output = Result<ValueWrapper<<usize as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: ValueWrapper<usize>) -> Self::Output

Performs the * operation.

impl<'a> Mul<f32> for ValueWrapper<&'a f32>

type Output = Result<ValueWrapper<<&'a f32 as Mul<f32>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<f32> for ValueWrapper<f32>

type Output = Result<ValueWrapper<<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 ValueWrapper<&'a f64>

type Output = Result<ValueWrapper<<&'a f64 as Mul<f64>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<f64> for ValueWrapper<f64>

type Output = Result<ValueWrapper<<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 ValueWrapper<&'a i128>

type Output = Result<ValueWrapper<<&'a i128 as Mul<i128>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<i128> for ValueWrapper<i128>

type Output = Result<ValueWrapper<<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 ValueWrapper<&'a i16>

type Output = Result<ValueWrapper<<&'a i16 as Mul<i16>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<i16> for ValueWrapper<i16>

type Output = Result<ValueWrapper<<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 ValueWrapper<&'a i32>

type Output = Result<ValueWrapper<<&'a i32 as Mul<i32>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<i32> for ValueWrapper<i32>

type Output = Result<ValueWrapper<<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 ValueWrapper<&'a i64>

type Output = Result<ValueWrapper<<&'a i64 as Mul<i64>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<i64> for ValueWrapper<i64>

type Output = Result<ValueWrapper<<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 ValueWrapper<&'a i8>

type Output = Result<ValueWrapper<<&'a i8 as Mul<i8>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<i8> for ValueWrapper<i8>

type Output = Result<ValueWrapper<<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 ValueWrapper<&'a isize>

type Output = Result<ValueWrapper<<&'a isize as Mul<isize>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<isize> for ValueWrapper<isize>

type Output = Result<ValueWrapper<<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 ValueWrapper<&'a u128>

type Output = Result<ValueWrapper<<&'a u128 as Mul<u128>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<u128> for ValueWrapper<u128>

type Output = Result<ValueWrapper<<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 ValueWrapper<&'a u16>

type Output = Result<ValueWrapper<<&'a u16 as Mul<u16>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<u16> for ValueWrapper<u16>

type Output = Result<ValueWrapper<<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 ValueWrapper<&'a u32>

type Output = Result<ValueWrapper<<&'a u32 as Mul<u32>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<u32> for ValueWrapper<u32>

type Output = Result<ValueWrapper<<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 ValueWrapper<&'a u64>

type Output = Result<ValueWrapper<<&'a u64 as Mul<u64>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<u64> for ValueWrapper<u64>

type Output = Result<ValueWrapper<<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 ValueWrapper<&'a u8>

type Output = Result<ValueWrapper<<&'a u8 as Mul<u8>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<u8> for ValueWrapper<u8>

type Output = Result<ValueWrapper<<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 ValueWrapper<&'a usize>

type Output = Result<ValueWrapper<<&'a usize as Mul<usize>>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<usize> for ValueWrapper<usize>

type Output = Result<ValueWrapper<<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 ValueWrapper<f32>

type Output = Result<ValueWrapper<<f32 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: ValueWrapper<f32>) -> Self::Output

Performs the * operation.

impl Mul for ValueWrapper<f64>

type Output = Result<ValueWrapper<<f64 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: ValueWrapper<f64>) -> Self::Output

Performs the * operation.

impl Mul for ValueWrapper<i128>

type Output = Result<ValueWrapper<<i128 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: ValueWrapper<i128>) -> Self::Output

Performs the * operation.

impl Mul for ValueWrapper<i16>

type Output = Result<ValueWrapper<<i16 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: ValueWrapper<i16>) -> Self::Output

Performs the * operation.

impl Mul for ValueWrapper<i32>

type Output = Result<ValueWrapper<<i32 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: ValueWrapper<i32>) -> Self::Output

Performs the * operation.

impl Mul for ValueWrapper<i64>

type Output = Result<ValueWrapper<<i64 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: ValueWrapper<i64>) -> Self::Output

Performs the * operation.

impl Mul for ValueWrapper<i8>

type Output = Result<ValueWrapper<<i8 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: ValueWrapper<i8>) -> Self::Output

Performs the * operation.

impl Mul for ValueWrapper<isize>

type Output = Result<ValueWrapper<<isize as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: ValueWrapper<isize>) -> Self::Output

Performs the * operation.

impl Mul for ValueWrapper<u128>

type Output = Result<ValueWrapper<<u128 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: ValueWrapper<u128>) -> Self::Output

Performs the * operation.

impl Mul for ValueWrapper<u16>

type Output = Result<ValueWrapper<<u16 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: ValueWrapper<u16>) -> Self::Output

Performs the * operation.

impl Mul for ValueWrapper<u32>

type Output = Result<ValueWrapper<<u32 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: ValueWrapper<u32>) -> Self::Output

Performs the * operation.

impl Mul for ValueWrapper<u64>

type Output = Result<ValueWrapper<<u64 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: ValueWrapper<u64>) -> Self::Output

Performs the * operation.

impl Mul for ValueWrapper<u8>

type Output = Result<ValueWrapper<<u8 as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: ValueWrapper<u8>) -> Self::Output

Performs the * operation.

impl Mul for ValueWrapper<usize>

type Output = Result<ValueWrapper<<usize as Mul>::Output>, IllegalArgumentError>

The resulting type after applying the * operator.

fn mul(self, rhs: ValueWrapper<usize>) -> Self::Output

Performs the * operation.

impl<'a> Neg for &'a ValueWrapper<f32>

type Output = Result<ValueWrapper<<&'a 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 ValueWrapper<f64>

type Output = Result<ValueWrapper<<&'a 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 ValueWrapper<i128>

type Output = Result<ValueWrapper<<&'a 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 ValueWrapper<i16>

type Output = Result<ValueWrapper<<&'a 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 ValueWrapper<i32>

type Output = Result<ValueWrapper<<&'a 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 ValueWrapper<i64>

type Output = Result<ValueWrapper<<&'a 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 ValueWrapper<i8>

type Output = Result<ValueWrapper<<&'a 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 ValueWrapper<isize>

type Output = Result<ValueWrapper<<&'a isize as Neg>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl Neg for ValueWrapper<f32>

type Output = Result<ValueWrapper<<f32 as Neg>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl Neg for ValueWrapper<f64>

type Output = Result<ValueWrapper<<f64 as Neg>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl Neg for ValueWrapper<i128>

type Output = Result<ValueWrapper<<i128 as Neg>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl Neg for ValueWrapper<i16>

type Output = Result<ValueWrapper<<i16 as Neg>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl Neg for ValueWrapper<i32>

type Output = Result<ValueWrapper<<i32 as Neg>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl Neg for ValueWrapper<i64>

type Output = Result<ValueWrapper<<i64 as Neg>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl Neg for ValueWrapper<i8>

type Output = Result<ValueWrapper<<i8 as Neg>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl Neg for ValueWrapper<isize>

type Output = Result<ValueWrapper<<isize as Neg>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl PartialEq<Duration> for ValueWrapper<Duration>

fn eq(&self, other: &Duration) -> 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 PartialEq<Instant> for ValueWrapper<Instant>

fn eq(&self, other: &Instant) -> 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 PartialEq<NaiveDateTime> for ValueWrapper<NaiveDateTime>

fn eq(&self, other: &NaiveDateTime) -> 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: SemiArithmetic> PartialEq<U> for ValueWrapper<T>

where T: PartialEq<U>,

default 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<T, U: RealNumber> PartialEq<U> for ValueWrapper<T>

where 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<T, U> PartialEq<ValueWrapper<U>> for ValueWrapper<T>

where T: PartialEq<U>,

default fn eq(&self, other: &ValueWrapper<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 PartialOrd<Duration> for ValueWrapper<Duration>

fn partial_cmp(&self, rhs: &Duration) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<Instant> for ValueWrapper<Instant>

fn partial_cmp(&self, rhs: &Instant) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<NaiveDateTime> for ValueWrapper<NaiveDateTime>

fn partial_cmp(&self, rhs: &NaiveDateTime) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T, U: SemiArithmetic> PartialOrd<U> for ValueWrapper<T>

where T: PartialOrd<U>,

default fn partial_cmp(&self, rhs: &U) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T, U: RealNumber> PartialOrd<U> for ValueWrapper<T>

where T: PartialOrd<U>,

fn partial_cmp(&self, rhs: &U) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T, U> PartialOrd<ValueWrapper<U>> for ValueWrapper<T>

where T: PartialOrd<U>,

default fn partial_cmp(&self, rhs: &ValueWrapper<U>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<'a, 'b> Sub<&'b Duration> for &'a ValueWrapper<Duration>

type Output = Result<ValueWrapper<<Duration as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b Duration) -> Self::Output

Performs the - operation.

impl<'a, 'b> Sub<&'b Duration> for &'a ValueWrapper<Instant>

type Output = Result<ValueWrapper<<Instant as Sub<Duration>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b Duration) -> Self::Output

Performs the - operation.

impl<'a, 'b> Sub<&'b Duration> for &'a ValueWrapper<NaiveDateTime>

type Output = Result<ValueWrapper<<NaiveDateTime as Sub<Duration>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b Duration) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a Duration> for ValueWrapper<Duration>

type Output = Result<ValueWrapper<<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 ValueWrapper<Instant>

type Output = Result<ValueWrapper<<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 ValueWrapper<NaiveDateTime>

type Output = Result<ValueWrapper<<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<&'b ValueWrapper<f32>> for &'a ValueWrapper<f32>

type Output = Result<ValueWrapper<<&'a f32 as Sub<&'b f32>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'a, 'b> Sub<&'b ValueWrapper<f32>> for &'a f32

type Output = Result<ValueWrapper<<&'a f32 as Sub<&'b f32>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'a> Sub<&'a ValueWrapper<f32>> for ValueWrapper<f32>

type Output = Result<ValueWrapper<<f32 as Sub<&'a f32>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'a> Sub<&'a ValueWrapper<f32>> for f32

type Output = Result<ValueWrapper<<f32 as Sub<&'a f32>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'a, 'b> Sub<&'b ValueWrapper<f64>> for &'a ValueWrapper<f64>

type Output = Result<ValueWrapper<<&'a f64 as Sub<&'b f64>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'a, 'b> Sub<&'b ValueWrapper<f64>> for &'a f64

type Output = Result<ValueWrapper<<&'a f64 as Sub<&'b f64>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'a> Sub<&'a ValueWrapper<f64>> for ValueWrapper<f64>

type Output = Result<ValueWrapper<<f64 as Sub<&'a f64>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'a> Sub<&'a ValueWrapper<f64>> for f64

type Output = Result<ValueWrapper<<f64 as Sub<&'a f64>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a ValueWrapper<f64>) -> Self::Output

Performs the - operation.

impl<'a, 'b> Sub<&'b ValueWrapper<i128>> for &'a ValueWrapper<i128>

type Output = Result<ValueWrapper<<&'a i128 as Sub<&'b i128>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b ValueWrapper<i128>) -> Self::Output

Performs the - operation.

impl<'a, 'b> Sub<&'b ValueWrapper<i128>> for &'a i128

type Output = Result<ValueWrapper<<&'a i128 as Sub<&'b i128>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b ValueWrapper<i128>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a ValueWrapper<i128>> for ValueWrapper<i128>

type Output = Result<ValueWrapper<<i128 as Sub<&'a i128>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a ValueWrapper<i128>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a ValueWrapper<i128>> for i128

type Output = Result<ValueWrapper<<i128 as Sub<&'a i128>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a ValueWrapper<i128>) -> Self::Output

Performs the - operation.

impl<'a, 'b> Sub<&'b ValueWrapper<i16>> for &'a ValueWrapper<i16>

type Output = Result<ValueWrapper<<&'a i16 as Sub<&'b i16>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b ValueWrapper<i16>) -> Self::Output

Performs the - operation.

impl<'a, 'b> Sub<&'b ValueWrapper<i16>> for &'a i16

type Output = Result<ValueWrapper<<&'a i16 as Sub<&'b i16>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b ValueWrapper<i16>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a ValueWrapper<i16>> for ValueWrapper<i16>

type Output = Result<ValueWrapper<<i16 as Sub<&'a i16>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a ValueWrapper<i16>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a ValueWrapper<i16>> for i16

type Output = Result<ValueWrapper<<i16 as Sub<&'a i16>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a ValueWrapper<i16>) -> Self::Output

Performs the - operation.

impl<'a, 'b> Sub<&'b ValueWrapper<i32>> for &'a ValueWrapper<i32>

type Output = Result<ValueWrapper<<&'a i32 as Sub<&'b i32>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b ValueWrapper<i32>) -> Self::Output

Performs the - operation.

impl<'a, 'b> Sub<&'b ValueWrapper<i32>> for &'a i32

type Output = Result<ValueWrapper<<&'a i32 as Sub<&'b i32>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b ValueWrapper<i32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a ValueWrapper<i32>> for ValueWrapper<i32>

type Output = Result<ValueWrapper<<i32 as Sub<&'a i32>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a ValueWrapper<i32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a ValueWrapper<i32>> for i32

type Output = Result<ValueWrapper<<i32 as Sub<&'a i32>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a ValueWrapper<i32>) -> Self::Output

Performs the - operation.

impl<'a, 'b> Sub<&'b ValueWrapper<i64>> for &'a ValueWrapper<i64>

type Output = Result<ValueWrapper<<&'a i64 as Sub<&'b i64>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b ValueWrapper<i64>) -> Self::Output

Performs the - operation.

impl<'a, 'b> Sub<&'b ValueWrapper<i64>> for &'a i64

type Output = Result<ValueWrapper<<&'a i64 as Sub<&'b i64>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b ValueWrapper<i64>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a ValueWrapper<i64>> for ValueWrapper<i64>

type Output = Result<ValueWrapper<<i64 as Sub<&'a i64>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a ValueWrapper<i64>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a ValueWrapper<i64>> for i64

type Output = Result<ValueWrapper<<i64 as Sub<&'a i64>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a ValueWrapper<i64>) -> Self::Output

Performs the - operation.

impl<'a, 'b> Sub<&'b ValueWrapper<i8>> for &'a ValueWrapper<i8>

type Output = Result<ValueWrapper<<&'a i8 as Sub<&'b i8>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b ValueWrapper<i8>) -> Self::Output

Performs the - operation.

impl<'a, 'b> Sub<&'b ValueWrapper<i8>> for &'a i8

type Output = Result<ValueWrapper<<&'a i8 as Sub<&'b i8>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b ValueWrapper<i8>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a ValueWrapper<i8>> for ValueWrapper<i8>

type Output = Result<ValueWrapper<<i8 as Sub<&'a i8>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a ValueWrapper<i8>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a ValueWrapper<i8>> for i8

type Output = Result<ValueWrapper<<i8 as Sub<&'a i8>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a ValueWrapper<i8>) -> Self::Output

Performs the - operation.

impl<'a, 'b> Sub<&'b ValueWrapper<isize>> for &'a ValueWrapper<isize>

type Output = Result<ValueWrapper<<&'a isize as Sub<&'b isize>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b ValueWrapper<isize>) -> Self::Output

Performs the - operation.

impl<'a, 'b> Sub<&'b ValueWrapper<isize>> for &'a isize

type Output = Result<ValueWrapper<<&'a isize as Sub<&'b isize>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b ValueWrapper<isize>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a ValueWrapper<isize>> for ValueWrapper<isize>

type Output = Result<ValueWrapper<<isize as Sub<&'a isize>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a ValueWrapper<isize>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a ValueWrapper<isize>> for isize

type Output = Result<ValueWrapper<<isize as Sub<&'a isize>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a ValueWrapper<isize>) -> Self::Output

Performs the - operation.

impl<'a, 'b> Sub<&'b ValueWrapper<u128>> for &'a ValueWrapper<u128>

type Output = Result<ValueWrapper<<&'a u128 as Sub<&'b u128>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b ValueWrapper<u128>) -> Self::Output

Performs the - operation.

impl<'a, 'b> Sub<&'b ValueWrapper<u128>> for &'a u128

type Output = Result<ValueWrapper<<&'a u128 as Sub<&'b u128>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b ValueWrapper<u128>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a ValueWrapper<u128>> for ValueWrapper<u128>

type Output = Result<ValueWrapper<<u128 as Sub<&'a u128>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a ValueWrapper<u128>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a ValueWrapper<u128>> for u128

type Output = Result<ValueWrapper<<u128 as Sub<&'a u128>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a ValueWrapper<u128>) -> Self::Output

Performs the - operation.

impl<'a, 'b> Sub<&'b ValueWrapper<u16>> for &'a ValueWrapper<u16>

type Output = Result<ValueWrapper<<&'a u16 as Sub<&'b u16>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b ValueWrapper<u16>) -> Self::Output

Performs the - operation.

impl<'a, 'b> Sub<&'b ValueWrapper<u16>> for &'a u16

type Output = Result<ValueWrapper<<&'a u16 as Sub<&'b u16>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b ValueWrapper<u16>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a ValueWrapper<u16>> for ValueWrapper<u16>

type Output = Result<ValueWrapper<<u16 as Sub<&'a u16>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a ValueWrapper<u16>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a ValueWrapper<u16>> for u16

type Output = Result<ValueWrapper<<u16 as Sub<&'a u16>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a ValueWrapper<u16>) -> Self::Output

Performs the - operation.

impl<'a, 'b> Sub<&'b ValueWrapper<u32>> for &'a ValueWrapper<u32>

type Output = Result<ValueWrapper<<&'a u32 as Sub<&'b u32>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b ValueWrapper<u32>) -> Self::Output

Performs the - operation.

impl<'a, 'b> Sub<&'b ValueWrapper<u32>> for &'a u32

type Output = Result<ValueWrapper<<&'a u32 as Sub<&'b u32>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b ValueWrapper<u32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a ValueWrapper<u32>> for ValueWrapper<u32>

type Output = Result<ValueWrapper<<u32 as Sub<&'a u32>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a ValueWrapper<u32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a ValueWrapper<u32>> for u32

type Output = Result<ValueWrapper<<u32 as Sub<&'a u32>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a ValueWrapper<u32>) -> Self::Output

Performs the - operation.

impl<'a, 'b> Sub<&'b ValueWrapper<u64>> for &'a ValueWrapper<u64>

type Output = Result<ValueWrapper<<&'a u64 as Sub<&'b u64>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b ValueWrapper<u64>) -> Self::Output

Performs the - operation.

impl<'a, 'b> Sub<&'b ValueWrapper<u64>> for &'a u64

type Output = Result<ValueWrapper<<&'a u64 as Sub<&'b u64>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b ValueWrapper<u64>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a ValueWrapper<u64>> for ValueWrapper<u64>

type Output = Result<ValueWrapper<<u64 as Sub<&'a u64>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a ValueWrapper<u64>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a ValueWrapper<u64>> for u64

type Output = Result<ValueWrapper<<u64 as Sub<&'a u64>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a ValueWrapper<u64>) -> Self::Output

Performs the - operation.

impl<'a, 'b> Sub<&'b ValueWrapper<u8>> for &'a ValueWrapper<u8>

type Output = Result<ValueWrapper<<&'a u8 as Sub<&'b u8>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b ValueWrapper<u8>) -> Self::Output

Performs the - operation.

impl<'a, 'b> Sub<&'b ValueWrapper<u8>> for &'a u8

type Output = Result<ValueWrapper<<&'a u8 as Sub<&'b u8>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b ValueWrapper<u8>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a ValueWrapper<u8>> for ValueWrapper<u8>

type Output = Result<ValueWrapper<<u8 as Sub<&'a u8>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a ValueWrapper<u8>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a ValueWrapper<u8>> for u8

type Output = Result<ValueWrapper<<u8 as Sub<&'a u8>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a ValueWrapper<u8>) -> Self::Output

Performs the - operation.

impl<'a, 'b> Sub<&'b ValueWrapper<usize>> for &'a ValueWrapper<usize>

type Output = Result<ValueWrapper<<&'a usize as Sub<&'b usize>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b ValueWrapper<usize>) -> Self::Output

Performs the - operation.

impl<'a, 'b> Sub<&'b ValueWrapper<usize>> for &'a usize

type Output = Result<ValueWrapper<<&'a usize as Sub<&'b usize>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b ValueWrapper<usize>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a ValueWrapper<usize>> for ValueWrapper<usize>

type Output = Result<ValueWrapper<<usize as Sub<&'a usize>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a ValueWrapper<usize>) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a ValueWrapper<usize>> for usize

type Output = Result<ValueWrapper<<usize as Sub<&'a usize>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a ValueWrapper<usize>) -> Self::Output

Performs the - operation.

impl<'a, 'b> Sub<&'b f32> for &'a ValueWrapper<f32>

type Output = Result<ValueWrapper<<&'a f32 as Sub<&'b f32>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b f32) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a f32> for ValueWrapper<f32>

type Output = Result<ValueWrapper<<f32 as Sub<&'a f32>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a f32) -> Self::Output

Performs the - operation.

impl<'a, 'b> Sub<&'b f64> for &'a ValueWrapper<f64>

type Output = Result<ValueWrapper<<&'a f64 as Sub<&'b f64>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b f64) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a f64> for ValueWrapper<f64>

type Output = Result<ValueWrapper<<f64 as Sub<&'a f64>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a f64) -> Self::Output

Performs the - operation.

impl<'a, 'b> Sub<&'b i128> for &'a ValueWrapper<i128>

type Output = Result<ValueWrapper<<&'a i128 as Sub<&'b i128>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b i128) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a i128> for ValueWrapper<i128>

type Output = Result<ValueWrapper<<i128 as Sub<&'a i128>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a i128) -> Self::Output

Performs the - operation.

impl<'a, 'b> Sub<&'b i16> for &'a ValueWrapper<i16>

type Output = Result<ValueWrapper<<&'a i16 as Sub<&'b i16>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b i16) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a i16> for ValueWrapper<i16>

type Output = Result<ValueWrapper<<i16 as Sub<&'a i16>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a i16) -> Self::Output

Performs the - operation.

impl<'a, 'b> Sub<&'b i32> for &'a ValueWrapper<i32>

type Output = Result<ValueWrapper<<&'a i32 as Sub<&'b i32>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b i32) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a i32> for ValueWrapper<i32>

type Output = Result<ValueWrapper<<i32 as Sub<&'a i32>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a i32) -> Self::Output

Performs the - operation.

impl<'a, 'b> Sub<&'b i64> for &'a ValueWrapper<i64>

type Output = Result<ValueWrapper<<&'a i64 as Sub<&'b i64>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b i64) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a i64> for ValueWrapper<i64>

type Output = Result<ValueWrapper<<i64 as Sub<&'a i64>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a i64) -> Self::Output

Performs the - operation.

impl<'a, 'b> Sub<&'b i8> for &'a ValueWrapper<i8>

type Output = Result<ValueWrapper<<&'a i8 as Sub<&'b i8>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b i8) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a i8> for ValueWrapper<i8>

type Output = Result<ValueWrapper<<i8 as Sub<&'a i8>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a i8) -> Self::Output

Performs the - operation.

impl<'a, 'b> Sub<&'b isize> for &'a ValueWrapper<isize>

type Output = Result<ValueWrapper<<&'a isize as Sub<&'b isize>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b isize) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a isize> for ValueWrapper<isize>

type Output = Result<ValueWrapper<<isize as Sub<&'a isize>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a isize) -> Self::Output

Performs the - operation.

impl<'a, 'b> Sub<&'b u128> for &'a ValueWrapper<u128>

type Output = Result<ValueWrapper<<&'a u128 as Sub<&'b u128>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b u128) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a u128> for ValueWrapper<u128>

type Output = Result<ValueWrapper<<u128 as Sub<&'a u128>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a u128) -> Self::Output

Performs the - operation.

impl<'a, 'b> Sub<&'b u16> for &'a ValueWrapper<u16>

type Output = Result<ValueWrapper<<&'a u16 as Sub<&'b u16>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b u16) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a u16> for ValueWrapper<u16>

type Output = Result<ValueWrapper<<u16 as Sub<&'a u16>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a u16) -> Self::Output

Performs the - operation.

impl<'a, 'b> Sub<&'b u32> for &'a ValueWrapper<u32>

type Output = Result<ValueWrapper<<&'a u32 as Sub<&'b u32>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b u32) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a u32> for ValueWrapper<u32>

type Output = Result<ValueWrapper<<u32 as Sub<&'a u32>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a u32) -> Self::Output

Performs the - operation.

impl<'a, 'b> Sub<&'b u64> for &'a ValueWrapper<u64>

type Output = Result<ValueWrapper<<&'a u64 as Sub<&'b u64>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b u64) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a u64> for ValueWrapper<u64>

type Output = Result<ValueWrapper<<u64 as Sub<&'a u64>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a u64) -> Self::Output

Performs the - operation.

impl<'a, 'b> Sub<&'b u8> for &'a ValueWrapper<u8>

type Output = Result<ValueWrapper<<&'a u8 as Sub<&'b u8>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b u8) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a u8> for ValueWrapper<u8>

type Output = Result<ValueWrapper<<u8 as Sub<&'a u8>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a u8) -> Self::Output

Performs the - operation.

impl<'a, 'b> Sub<&'b usize> for &'a ValueWrapper<usize>

type Output = Result<ValueWrapper<<&'a usize as Sub<&'b usize>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b usize) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a usize> for ValueWrapper<usize>

type Output = Result<ValueWrapper<<usize as Sub<&'a usize>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a usize) -> Self::Output

Performs the - operation.

impl<'a> Sub<Duration> for &'a ValueWrapper<Duration>

type Output = Result<ValueWrapper<<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 ValueWrapper<Instant>

type Output = Result<ValueWrapper<<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 ValueWrapper<NaiveDateTime>

type Output = Result<ValueWrapper<<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 ValueWrapper<Duration>

type Output = Result<ValueWrapper<<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 ValueWrapper<Instant>

type Output = Result<ValueWrapper<<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 ValueWrapper<NaiveDateTime>

type Output = Result<ValueWrapper<<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<ValueWrapper<f32>> for &'a ValueWrapper<f32>

type Output = Result<ValueWrapper<<f32 as Sub<&'a f32>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: ValueWrapper<f32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<ValueWrapper<f32>> for &'a f32

type Output = Result<ValueWrapper<<&'a f32 as Sub<f32>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: ValueWrapper<f32>) -> Self::Output

Performs the - operation.

impl Sub<ValueWrapper<f32>> for f32

type Output = Result<ValueWrapper<<f32 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: ValueWrapper<f32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<ValueWrapper<f64>> for &'a ValueWrapper<f64>

type Output = Result<ValueWrapper<<f64 as Sub<&'a f64>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: ValueWrapper<f64>) -> Self::Output

Performs the - operation.

impl<'a> Sub<ValueWrapper<f64>> for &'a f64

type Output = Result<ValueWrapper<<&'a f64 as Sub<f64>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: ValueWrapper<f64>) -> Self::Output

Performs the - operation.

impl Sub<ValueWrapper<f64>> for f64

type Output = Result<ValueWrapper<<f64 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: ValueWrapper<f64>) -> Self::Output

Performs the - operation.

impl<'a> Sub<ValueWrapper<i128>> for &'a ValueWrapper<i128>

type Output = Result<ValueWrapper<<i128 as Sub<&'a i128>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: ValueWrapper<i128>) -> Self::Output

Performs the - operation.

impl<'a> Sub<ValueWrapper<i128>> for &'a i128

type Output = Result<ValueWrapper<<&'a i128 as Sub<i128>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: ValueWrapper<i128>) -> Self::Output

Performs the - operation.

impl Sub<ValueWrapper<i128>> for i128

type Output = Result<ValueWrapper<<i128 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: ValueWrapper<i128>) -> Self::Output

Performs the - operation.

impl<'a> Sub<ValueWrapper<i16>> for &'a ValueWrapper<i16>

type Output = Result<ValueWrapper<<i16 as Sub<&'a i16>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: ValueWrapper<i16>) -> Self::Output

Performs the - operation.

impl<'a> Sub<ValueWrapper<i16>> for &'a i16

type Output = Result<ValueWrapper<<&'a i16 as Sub<i16>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: ValueWrapper<i16>) -> Self::Output

Performs the - operation.

impl Sub<ValueWrapper<i16>> for i16

type Output = Result<ValueWrapper<<i16 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: ValueWrapper<i16>) -> Self::Output

Performs the - operation.

impl<'a> Sub<ValueWrapper<i32>> for &'a ValueWrapper<i32>

type Output = Result<ValueWrapper<<i32 as Sub<&'a i32>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: ValueWrapper<i32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<ValueWrapper<i32>> for &'a i32

type Output = Result<ValueWrapper<<&'a i32 as Sub<i32>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: ValueWrapper<i32>) -> Self::Output

Performs the - operation.

impl Sub<ValueWrapper<i32>> for i32

type Output = Result<ValueWrapper<<i32 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: ValueWrapper<i32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<ValueWrapper<i64>> for &'a ValueWrapper<i64>

type Output = Result<ValueWrapper<<i64 as Sub<&'a i64>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: ValueWrapper<i64>) -> Self::Output

Performs the - operation.

impl<'a> Sub<ValueWrapper<i64>> for &'a i64

type Output = Result<ValueWrapper<<&'a i64 as Sub<i64>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: ValueWrapper<i64>) -> Self::Output

Performs the - operation.

impl Sub<ValueWrapper<i64>> for i64

type Output = Result<ValueWrapper<<i64 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: ValueWrapper<i64>) -> Self::Output

Performs the - operation.

impl<'a> Sub<ValueWrapper<i8>> for &'a ValueWrapper<i8>

type Output = Result<ValueWrapper<<i8 as Sub<&'a i8>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: ValueWrapper<i8>) -> Self::Output

Performs the - operation.

impl<'a> Sub<ValueWrapper<i8>> for &'a i8

type Output = Result<ValueWrapper<<&'a i8 as Sub<i8>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: ValueWrapper<i8>) -> Self::Output

Performs the - operation.

impl Sub<ValueWrapper<i8>> for i8

type Output = Result<ValueWrapper<<i8 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: ValueWrapper<i8>) -> Self::Output

Performs the - operation.

impl<'a> Sub<ValueWrapper<isize>> for &'a ValueWrapper<isize>

type Output = Result<ValueWrapper<<isize as Sub<&'a isize>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: ValueWrapper<isize>) -> Self::Output

Performs the - operation.

impl<'a> Sub<ValueWrapper<isize>> for &'a isize

type Output = Result<ValueWrapper<<&'a isize as Sub<isize>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: ValueWrapper<isize>) -> Self::Output

Performs the - operation.

impl Sub<ValueWrapper<isize>> for isize

type Output = Result<ValueWrapper<<isize as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: ValueWrapper<isize>) -> Self::Output

Performs the - operation.

impl<'a> Sub<ValueWrapper<u128>> for &'a ValueWrapper<u128>

type Output = Result<ValueWrapper<<u128 as Sub<&'a u128>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: ValueWrapper<u128>) -> Self::Output

Performs the - operation.

impl<'a> Sub<ValueWrapper<u128>> for &'a u128

type Output = Result<ValueWrapper<<&'a u128 as Sub<u128>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: ValueWrapper<u128>) -> Self::Output

Performs the - operation.

impl Sub<ValueWrapper<u128>> for u128

type Output = Result<ValueWrapper<<u128 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: ValueWrapper<u128>) -> Self::Output

Performs the - operation.

impl<'a> Sub<ValueWrapper<u16>> for &'a ValueWrapper<u16>

type Output = Result<ValueWrapper<<u16 as Sub<&'a u16>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: ValueWrapper<u16>) -> Self::Output

Performs the - operation.

impl<'a> Sub<ValueWrapper<u16>> for &'a u16

type Output = Result<ValueWrapper<<&'a u16 as Sub<u16>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: ValueWrapper<u16>) -> Self::Output

Performs the - operation.

impl Sub<ValueWrapper<u16>> for u16

type Output = Result<ValueWrapper<<u16 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: ValueWrapper<u16>) -> Self::Output

Performs the - operation.

impl<'a> Sub<ValueWrapper<u32>> for &'a ValueWrapper<u32>

type Output = Result<ValueWrapper<<u32 as Sub<&'a u32>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: ValueWrapper<u32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<ValueWrapper<u32>> for &'a u32

type Output = Result<ValueWrapper<<&'a u32 as Sub<u32>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: ValueWrapper<u32>) -> Self::Output

Performs the - operation.

impl Sub<ValueWrapper<u32>> for u32

type Output = Result<ValueWrapper<<u32 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: ValueWrapper<u32>) -> Self::Output

Performs the - operation.

impl<'a> Sub<ValueWrapper<u64>> for &'a ValueWrapper<u64>

type Output = Result<ValueWrapper<<u64 as Sub<&'a u64>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: ValueWrapper<u64>) -> Self::Output

Performs the - operation.

impl<'a> Sub<ValueWrapper<u64>> for &'a u64

type Output = Result<ValueWrapper<<&'a u64 as Sub<u64>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: ValueWrapper<u64>) -> Self::Output

Performs the - operation.

impl Sub<ValueWrapper<u64>> for u64

type Output = Result<ValueWrapper<<u64 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: ValueWrapper<u64>) -> Self::Output

Performs the - operation.

impl<'a> Sub<ValueWrapper<u8>> for &'a ValueWrapper<u8>

type Output = Result<ValueWrapper<<u8 as Sub<&'a u8>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: ValueWrapper<u8>) -> Self::Output

Performs the - operation.

impl<'a> Sub<ValueWrapper<u8>> for &'a u8

type Output = Result<ValueWrapper<<&'a u8 as Sub<u8>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: ValueWrapper<u8>) -> Self::Output

Performs the - operation.

impl Sub<ValueWrapper<u8>> for u8

type Output = Result<ValueWrapper<<u8 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: ValueWrapper<u8>) -> Self::Output

Performs the - operation.

impl<'a> Sub<ValueWrapper<usize>> for &'a ValueWrapper<usize>

type Output = Result<ValueWrapper<<usize as Sub<&'a usize>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: ValueWrapper<usize>) -> Self::Output

Performs the - operation.

impl<'a> Sub<ValueWrapper<usize>> for &'a usize

type Output = Result<ValueWrapper<<&'a usize as Sub<usize>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: ValueWrapper<usize>) -> Self::Output

Performs the - operation.

impl Sub<ValueWrapper<usize>> for usize

type Output = Result<ValueWrapper<<usize as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: ValueWrapper<usize>) -> Self::Output

Performs the - operation.

impl<'a> Sub<f32> for &'a ValueWrapper<f32>

type Output = Result<ValueWrapper<<&'a f32 as Sub<f32>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: f32) -> Self::Output

Performs the - operation.

impl Sub<f32> for ValueWrapper<f32>

type Output = Result<ValueWrapper<<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 ValueWrapper<f64>

type Output = Result<ValueWrapper<<&'a f64 as Sub<f64>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: f64) -> Self::Output

Performs the - operation.

impl Sub<f64> for ValueWrapper<f64>

type Output = Result<ValueWrapper<<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 ValueWrapper<i128>

type Output = Result<ValueWrapper<<&'a i128 as Sub<i128>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: i128) -> Self::Output

Performs the - operation.

impl Sub<i128> for ValueWrapper<i128>

type Output = Result<ValueWrapper<<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 ValueWrapper<i16>

type Output = Result<ValueWrapper<<&'a i16 as Sub<i16>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: i16) -> Self::Output

Performs the - operation.

impl Sub<i16> for ValueWrapper<i16>

type Output = Result<ValueWrapper<<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 ValueWrapper<i32>

type Output = Result<ValueWrapper<<&'a i32 as Sub<i32>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: i32) -> Self::Output

Performs the - operation.

impl Sub<i32> for ValueWrapper<i32>

type Output = Result<ValueWrapper<<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 ValueWrapper<i64>

type Output = Result<ValueWrapper<<&'a i64 as Sub<i64>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: i64) -> Self::Output

Performs the - operation.

impl Sub<i64> for ValueWrapper<i64>

type Output = Result<ValueWrapper<<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 ValueWrapper<i8>

type Output = Result<ValueWrapper<<&'a i8 as Sub<i8>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: i8) -> Self::Output

Performs the - operation.

impl Sub<i8> for ValueWrapper<i8>

type Output = Result<ValueWrapper<<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 ValueWrapper<isize>

type Output = Result<ValueWrapper<<&'a isize as Sub<isize>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: isize) -> Self::Output

Performs the - operation.

impl Sub<isize> for ValueWrapper<isize>

type Output = Result<ValueWrapper<<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 ValueWrapper<u128>

type Output = Result<ValueWrapper<<&'a u128 as Sub<u128>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: u128) -> Self::Output

Performs the - operation.

impl Sub<u128> for ValueWrapper<u128>

type Output = Result<ValueWrapper<<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 ValueWrapper<u16>

type Output = Result<ValueWrapper<<&'a u16 as Sub<u16>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: u16) -> Self::Output

Performs the - operation.

impl Sub<u16> for ValueWrapper<u16>

type Output = Result<ValueWrapper<<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 ValueWrapper<u32>

type Output = Result<ValueWrapper<<&'a u32 as Sub<u32>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: u32) -> Self::Output

Performs the - operation.

impl Sub<u32> for ValueWrapper<u32>

type Output = Result<ValueWrapper<<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 ValueWrapper<u64>

type Output = Result<ValueWrapper<<&'a u64 as Sub<u64>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: u64) -> Self::Output

Performs the - operation.

impl Sub<u64> for ValueWrapper<u64>

type Output = Result<ValueWrapper<<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 ValueWrapper<u8>

type Output = Result<ValueWrapper<<&'a u8 as Sub<u8>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: u8) -> Self::Output

Performs the - operation.

impl Sub<u8> for ValueWrapper<u8>

type Output = Result<ValueWrapper<<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 ValueWrapper<usize>

type Output = Result<ValueWrapper<<&'a usize as Sub<usize>>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: usize) -> Self::Output

Performs the - operation.

impl Sub<usize> for ValueWrapper<usize>

type Output = Result<ValueWrapper<<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 ValueWrapper<f32>

type Output = Result<ValueWrapper<<f32 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: ValueWrapper<f32>) -> Self::Output

Performs the - operation.

impl Sub for ValueWrapper<f64>

type Output = Result<ValueWrapper<<f64 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: ValueWrapper<f64>) -> Self::Output

Performs the - operation.

impl Sub for ValueWrapper<i128>

type Output = Result<ValueWrapper<<i128 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: ValueWrapper<i128>) -> Self::Output

Performs the - operation.

impl Sub for ValueWrapper<i16>

type Output = Result<ValueWrapper<<i16 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: ValueWrapper<i16>) -> Self::Output

Performs the - operation.

impl Sub for ValueWrapper<i32>

type Output = Result<ValueWrapper<<i32 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: ValueWrapper<i32>) -> Self::Output

Performs the - operation.

impl Sub for ValueWrapper<i64>

type Output = Result<ValueWrapper<<i64 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: ValueWrapper<i64>) -> Self::Output

Performs the - operation.

impl Sub for ValueWrapper<i8>

type Output = Result<ValueWrapper<<i8 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: ValueWrapper<i8>) -> Self::Output

Performs the - operation.

impl Sub for ValueWrapper<isize>

type Output = Result<ValueWrapper<<isize as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: ValueWrapper<isize>) -> Self::Output

Performs the - operation.

impl Sub for ValueWrapper<u128>

type Output = Result<ValueWrapper<<u128 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: ValueWrapper<u128>) -> Self::Output

Performs the - operation.

impl Sub for ValueWrapper<u16>

type Output = Result<ValueWrapper<<u16 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: ValueWrapper<u16>) -> Self::Output

Performs the - operation.

impl Sub for ValueWrapper<u32>

type Output = Result<ValueWrapper<<u32 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: ValueWrapper<u32>) -> Self::Output

Performs the - operation.

impl Sub for ValueWrapper<u64>

type Output = Result<ValueWrapper<<u64 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: ValueWrapper<u64>) -> Self::Output

Performs the - operation.

impl Sub for ValueWrapper<u8>

type Output = Result<ValueWrapper<<u8 as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: ValueWrapper<u8>) -> Self::Output

Performs the - operation.

impl Sub for ValueWrapper<usize>

type Output = Result<ValueWrapper<<usize as Sub>::Output>, IllegalArgumentError>

The resulting type after applying the - operator.

fn sub(self, rhs: ValueWrapper<usize>) -> Self::Output

Performs the - operation.

impl<T> ValueWrapperUnwrap<T> for ValueWrapper<T>

default fn unwrap(&self) -> &T

impl<T: RealNumber> ValueWrapperUnwrap<T> for ValueWrapper<T>

fn unwrap(&self) -> &T

impl<T: Copy> Copy for ValueWrapper<T>