Trait scale_info::prelude::ops::RemAssign

1.8.0 · source ·
pub trait RemAssign<Rhs = Self> {
    fn rem_assign(&mut self, rhs: Rhs);
}
Expand description

The remainder assignment operator %=.

Examples

use std::ops::RemAssign;

struct CookieJar { cookies: u32 }

impl RemAssign<u32> for CookieJar {
    fn rem_assign(&mut self, piles: u32) {
        self.cookies %= piles;
    }
}

let mut jar = CookieJar { cookies: 31 };
let piles = 4;

println!("Splitting up {} cookies into {} even piles!", jar.cookies, piles);

jar %= piles;

println!("{} cookies remain in the cookie jar!", jar.cookies);

Required Methods§

Performs the %= operation.

Example
let mut x: u32 = 12;
x %= 10;
assert_eq!(x, 2);

Implementors§

impl<const LIMBS: usize> RemAssign<&NonZero<UInt<LIMBS>>> for UInt<LIMBS>where
    UInt<LIMBS>: Integer,

impl<const LIMBS: usize> RemAssign<NonZero<UInt<LIMBS>>> for UInt<LIMBS>where
    UInt<LIMBS>: Integer,

impl<const LIMBS: usize> RemAssign<NonZero<UInt<LIMBS>>> for Wrapping<UInt<LIMBS>>

impl<const LIMBS: usize> RemAssign<&NonZero<UInt<LIMBS>>> for Wrapping<UInt<LIMBS>>

impl<Frac> RemAssign<FixedU8<Frac>> for FixedU8<Frac>

impl<Frac> RemAssign<&FixedU8<Frac>> for FixedU8<Frac>

impl<Frac: LeEqU8> RemAssign<u8> for FixedU8<Frac>

impl<Frac: LeEqU8> RemAssign<&u8> for FixedU8<Frac>

impl<Frac: LeEqU8> RemAssign<NonZeroU8> for FixedU8<Frac>

impl<Frac: LeEqU8> RemAssign<&NonZeroU8> for FixedU8<Frac>

impl<Frac> RemAssign<FixedU16<Frac>> for FixedU16<Frac>

impl<Frac> RemAssign<&FixedU16<Frac>> for FixedU16<Frac>

impl<Frac: LeEqU16> RemAssign<u16> for FixedU16<Frac>

impl<Frac: LeEqU16> RemAssign<&u16> for FixedU16<Frac>

impl<Frac: LeEqU16> RemAssign<NonZeroU16> for FixedU16<Frac>

impl<Frac: LeEqU16> RemAssign<&NonZeroU16> for FixedU16<Frac>

impl<Frac> RemAssign<FixedU32<Frac>> for FixedU32<Frac>

impl<Frac> RemAssign<&FixedU32<Frac>> for FixedU32<Frac>

impl<Frac: LeEqU32> RemAssign<u32> for FixedU32<Frac>

impl<Frac: LeEqU32> RemAssign<&u32> for FixedU32<Frac>

impl<Frac: LeEqU32> RemAssign<NonZeroU32> for FixedU32<Frac>

impl<Frac: LeEqU32> RemAssign<&NonZeroU32> for FixedU32<Frac>

impl<Frac> RemAssign<FixedU64<Frac>> for FixedU64<Frac>

impl<Frac> RemAssign<&FixedU64<Frac>> for FixedU64<Frac>

impl<Frac: LeEqU64> RemAssign<u64> for FixedU64<Frac>

impl<Frac: LeEqU64> RemAssign<&u64> for FixedU64<Frac>

impl<Frac: LeEqU64> RemAssign<NonZeroU64> for FixedU64<Frac>

impl<Frac: LeEqU64> RemAssign<&NonZeroU64> for FixedU64<Frac>

impl<Frac> RemAssign<FixedU128<Frac>> for FixedU128<Frac>

impl<Frac> RemAssign<&FixedU128<Frac>> for FixedU128<Frac>

impl<Frac: LeEqU128> RemAssign<u128> for FixedU128<Frac>

impl<Frac: LeEqU128> RemAssign<&u128> for FixedU128<Frac>

impl<Frac: LeEqU128> RemAssign<NonZeroU128> for FixedU128<Frac>

impl<Frac: LeEqU128> RemAssign<&NonZeroU128> for FixedU128<Frac>

impl<Frac> RemAssign<FixedI8<Frac>> for FixedI8<Frac>

impl<Frac> RemAssign<&FixedI8<Frac>> for FixedI8<Frac>

impl<Frac: LeEqU8> RemAssign<i8> for FixedI8<Frac>

impl<Frac: LeEqU8> RemAssign<&i8> for FixedI8<Frac>

impl<Frac: LeEqU8> RemAssign<NonZeroI8> for FixedI8<Frac>

impl<Frac: LeEqU8> RemAssign<&NonZeroI8> for FixedI8<Frac>

impl<Frac> RemAssign<FixedI16<Frac>> for FixedI16<Frac>

impl<Frac> RemAssign<&FixedI16<Frac>> for FixedI16<Frac>

impl<Frac: LeEqU16> RemAssign<i16> for FixedI16<Frac>

impl<Frac: LeEqU16> RemAssign<&i16> for FixedI16<Frac>

impl<Frac: LeEqU16> RemAssign<NonZeroI16> for FixedI16<Frac>

impl<Frac: LeEqU16> RemAssign<&NonZeroI16> for FixedI16<Frac>

impl<Frac> RemAssign<FixedI32<Frac>> for FixedI32<Frac>

impl<Frac> RemAssign<&FixedI32<Frac>> for FixedI32<Frac>

impl<Frac: LeEqU32> RemAssign<i32> for FixedI32<Frac>

impl<Frac: LeEqU32> RemAssign<&i32> for FixedI32<Frac>

impl<Frac: LeEqU32> RemAssign<NonZeroI32> for FixedI32<Frac>

impl<Frac: LeEqU32> RemAssign<&NonZeroI32> for FixedI32<Frac>

impl<Frac> RemAssign<FixedI64<Frac>> for FixedI64<Frac>

impl<Frac> RemAssign<&FixedI64<Frac>> for FixedI64<Frac>

impl<Frac: LeEqU64> RemAssign<i64> for FixedI64<Frac>

impl<Frac: LeEqU64> RemAssign<&i64> for FixedI64<Frac>

impl<Frac: LeEqU64> RemAssign<NonZeroI64> for FixedI64<Frac>

impl<Frac: LeEqU64> RemAssign<&NonZeroI64> for FixedI64<Frac>

impl<Frac> RemAssign<FixedI128<Frac>> for FixedI128<Frac>

impl<Frac> RemAssign<&FixedI128<Frac>> for FixedI128<Frac>

impl<Frac: LeEqU128> RemAssign<i128> for FixedI128<Frac>

impl<Frac: LeEqU128> RemAssign<&i128> for FixedI128<Frac>

impl<Frac: LeEqU128> RemAssign<NonZeroI128> for FixedI128<Frac>

impl<Frac: LeEqU128> RemAssign<&NonZeroI128> for FixedI128<Frac>

impl<F: Fixed> RemAssign<Unwrapped<F>> for Unwrapped<F>

impl<F: Fixed> RemAssign<&Unwrapped<F>> for Unwrapped<F>

impl<F: Fixed> RemAssign<F> for Unwrapped<F>

impl<F: Fixed> RemAssign<&F> for Unwrapped<F>

impl<Frac: LeEqU8> RemAssign<i8> for Unwrapped<FixedI8<Frac>>

impl<Frac: LeEqU8> RemAssign<&i8> for Unwrapped<FixedI8<Frac>>

impl<Frac: LeEqU16> RemAssign<i16> for Unwrapped<FixedI16<Frac>>

impl<Frac: LeEqU16> RemAssign<&i16> for Unwrapped<FixedI16<Frac>>

impl<Frac: LeEqU32> RemAssign<i32> for Unwrapped<FixedI32<Frac>>

impl<Frac: LeEqU32> RemAssign<&i32> for Unwrapped<FixedI32<Frac>>

impl<Frac: LeEqU64> RemAssign<i64> for Unwrapped<FixedI64<Frac>>

impl<Frac: LeEqU64> RemAssign<&i64> for Unwrapped<FixedI64<Frac>>

impl<Frac: LeEqU128> RemAssign<i128> for Unwrapped<FixedI128<Frac>>

impl<Frac: LeEqU128> RemAssign<&i128> for Unwrapped<FixedI128<Frac>>

impl<Frac: LeEqU8> RemAssign<u8> for Unwrapped<FixedU8<Frac>>

impl<Frac: LeEqU8> RemAssign<&u8> for Unwrapped<FixedU8<Frac>>

impl<Frac: LeEqU16> RemAssign<u16> for Unwrapped<FixedU16<Frac>>

impl<Frac: LeEqU16> RemAssign<&u16> for Unwrapped<FixedU16<Frac>>

impl<Frac: LeEqU32> RemAssign<u32> for Unwrapped<FixedU32<Frac>>

impl<Frac: LeEqU32> RemAssign<&u32> for Unwrapped<FixedU32<Frac>>

impl<Frac: LeEqU64> RemAssign<u64> for Unwrapped<FixedU64<Frac>>

impl<Frac: LeEqU64> RemAssign<&u64> for Unwrapped<FixedU64<Frac>>

impl<Frac: LeEqU128> RemAssign<u128> for Unwrapped<FixedU128<Frac>>

impl<Frac: LeEqU128> RemAssign<&u128> for Unwrapped<FixedU128<Frac>>

impl<F: Fixed> RemAssign<Wrapping<F>> for Wrapping<F>

impl<F: Fixed> RemAssign<&Wrapping<F>> for Wrapping<F>

impl<F: Fixed> RemAssign<F> for Wrapping<F>

impl<F: Fixed> RemAssign<&F> for Wrapping<F>

impl<Frac: LeEqU8> RemAssign<i8> for Wrapping<FixedI8<Frac>>

impl<Frac: LeEqU8> RemAssign<&i8> for Wrapping<FixedI8<Frac>>

impl<Frac: LeEqU16> RemAssign<i16> for Wrapping<FixedI16<Frac>>

impl<Frac: LeEqU16> RemAssign<&i16> for Wrapping<FixedI16<Frac>>

impl<Frac: LeEqU32> RemAssign<i32> for Wrapping<FixedI32<Frac>>

impl<Frac: LeEqU32> RemAssign<&i32> for Wrapping<FixedI32<Frac>>

impl<Frac: LeEqU64> RemAssign<i64> for Wrapping<FixedI64<Frac>>

impl<Frac: LeEqU64> RemAssign<&i64> for Wrapping<FixedI64<Frac>>

impl<Frac: LeEqU128> RemAssign<i128> for Wrapping<FixedI128<Frac>>

impl<Frac: LeEqU128> RemAssign<&i128> for Wrapping<FixedI128<Frac>>

impl<Frac: LeEqU8> RemAssign<u8> for Wrapping<FixedU8<Frac>>

impl<Frac: LeEqU8> RemAssign<&u8> for Wrapping<FixedU8<Frac>>

impl<Frac: LeEqU16> RemAssign<u16> for Wrapping<FixedU16<Frac>>

impl<Frac: LeEqU16> RemAssign<&u16> for Wrapping<FixedU16<Frac>>

impl<Frac: LeEqU32> RemAssign<u32> for Wrapping<FixedU32<Frac>>

impl<Frac: LeEqU32> RemAssign<&u32> for Wrapping<FixedU32<Frac>>

impl<Frac: LeEqU64> RemAssign<u64> for Wrapping<FixedU64<Frac>>

impl<Frac: LeEqU64> RemAssign<&u64> for Wrapping<FixedU64<Frac>>

impl<Frac: LeEqU128> RemAssign<u128> for Wrapping<FixedU128<Frac>>

impl<Frac: LeEqU128> RemAssign<&u128> for Wrapping<FixedU128<Frac>>

impl RemAssign<bf16> for bf16

impl RemAssign<&bf16> for bf16

impl RemAssign<f16> for f16

impl RemAssign<&f16> for f16

impl<'a> RemAssign<&'a BigInt> for BigInt

impl RemAssign<u8> for BigInt

impl RemAssign<u16> for BigInt

impl RemAssign<i8> for BigInt

impl RemAssign<i16> for BigInt

impl RemAssign<u32> for BigInt

impl RemAssign<u64> for BigInt

impl RemAssign<i32> for BigInt

impl RemAssign<i64> for BigInt

impl<'a> RemAssign<&'a BigUint> for BigUint

impl RemAssign<u8> for BigUint

impl<'a> RemAssign<&'a BigUint> for u128

impl<'a> RemAssign<&'a BigUint> for usize

impl<'a> RemAssign<&'a BigUint> for u64

impl<'a> RemAssign<&'a BigUint> for u32

impl<'a> RemAssign<&'a BigUint> for u16

impl RemAssign<BigUint> for u8

impl<'a> RemAssign<&'a BigUint> for u8

impl<'a> RemAssign<&'a BigUint> for i128

impl<'a> RemAssign<&'a BigUint> for isize

impl<'a> RemAssign<&'a BigUint> for i64

impl<'a> RemAssign<&'a BigUint> for i32

impl<'a> RemAssign<&'a BigUint> for i16

impl RemAssign<BigUint> for i8

impl<'a> RemAssign<&'a BigUint> for i8

impl<T: Clone + NumAssign> RemAssign<Complex<T>> for Complex<T>

impl<T: Clone + NumAssign> RemAssign<T> for Complex<T>

impl<'a, T: Clone + NumAssign> RemAssign<&'a Complex<T>> for Complex<T>

impl<'a, T: Clone + NumAssign> RemAssign<&'a T> for Complex<T>

impl<T: Clone + Integer + NumAssign> RemAssign<Ratio<T>> for Ratio<T>

impl<T: Clone + Integer + NumAssign> RemAssign<T> for Ratio<T>

impl<'a, T: Clone + Integer + NumAssign> RemAssign<&'a Ratio<T>> for Ratio<T>

impl<'a, T: Clone + Integer + NumAssign> RemAssign<&'a T> for Ratio<T>

impl<T: Float + RemAssign> RemAssign<NotNan<T>> for NotNan<T>

impl<T: Float + RemAssign> RemAssign<T> for NotNan<T>

impl<T> RemAssign<T> for U128where
    T: Into<U128> + Copy,

impl<T> RemAssign<T> for U256where
    T: Into<U256> + Copy,

impl<T> RemAssign<T> for U512where
    T: Into<U512> + Copy,

impl RemAssign<AutoSimd<[f32; 2]>> for AutoSimd<[f32; 2]>

impl RemAssign<AutoSimd<[f32; 4]>> for AutoSimd<[f32; 4]>

impl RemAssign<AutoSimd<[f32; 8]>> for AutoSimd<[f32; 8]>

impl RemAssign<AutoSimd<[f32; 16]>> for AutoSimd<[f32; 16]>

impl RemAssign<AutoSimd<[f64; 2]>> for AutoSimd<[f64; 2]>

impl RemAssign<AutoSimd<[f64; 4]>> for AutoSimd<[f64; 4]>

impl RemAssign<AutoSimd<[f64; 8]>> for AutoSimd<[f64; 8]>

impl RemAssign<AutoSimd<[i128; 1]>> for AutoSimd<[i128; 1]>

impl RemAssign<AutoSimd<[i128; 2]>> for AutoSimd<[i128; 2]>

impl RemAssign<AutoSimd<[i128; 4]>> for AutoSimd<[i128; 4]>

impl RemAssign<AutoSimd<[i16; 2]>> for AutoSimd<[i16; 2]>

impl RemAssign<AutoSimd<[i16; 4]>> for AutoSimd<[i16; 4]>

impl RemAssign<AutoSimd<[i16; 8]>> for AutoSimd<[i16; 8]>

impl RemAssign<AutoSimd<[i16; 16]>> for AutoSimd<[i16; 16]>

impl RemAssign<AutoSimd<[i16; 32]>> for AutoSimd<[i16; 32]>

impl RemAssign<AutoSimd<[i32; 2]>> for AutoSimd<[i32; 2]>

impl RemAssign<AutoSimd<[i32; 4]>> for AutoSimd<[i32; 4]>

impl RemAssign<AutoSimd<[i32; 8]>> for AutoSimd<[i32; 8]>

impl RemAssign<AutoSimd<[i32; 16]>> for AutoSimd<[i32; 16]>

impl RemAssign<AutoSimd<[i64; 2]>> for AutoSimd<[i64; 2]>

impl RemAssign<AutoSimd<[i64; 4]>> for AutoSimd<[i64; 4]>

impl RemAssign<AutoSimd<[i64; 8]>> for AutoSimd<[i64; 8]>

impl RemAssign<AutoSimd<[i8; 2]>> for AutoSimd<[i8; 2]>

impl RemAssign<AutoSimd<[i8; 4]>> for AutoSimd<[i8; 4]>

impl RemAssign<AutoSimd<[i8; 8]>> for AutoSimd<[i8; 8]>

impl RemAssign<AutoSimd<[i8; 16]>> for AutoSimd<[i8; 16]>

impl RemAssign<AutoSimd<[i8; 32]>> for AutoSimd<[i8; 32]>

impl RemAssign<AutoSimd<[u128; 1]>> for AutoSimd<[u128; 1]>

impl RemAssign<AutoSimd<[u128; 2]>> for AutoSimd<[u128; 2]>

impl RemAssign<AutoSimd<[u128; 4]>> for AutoSimd<[u128; 4]>

impl RemAssign<AutoSimd<[u16; 2]>> for AutoSimd<[u16; 2]>

impl RemAssign<AutoSimd<[u16; 4]>> for AutoSimd<[u16; 4]>

impl RemAssign<AutoSimd<[u16; 8]>> for AutoSimd<[u16; 8]>

impl RemAssign<AutoSimd<[u16; 16]>> for AutoSimd<[u16; 16]>

impl RemAssign<AutoSimd<[u16; 32]>> for AutoSimd<[u16; 32]>

impl RemAssign<AutoSimd<[u32; 2]>> for AutoSimd<[u32; 2]>

impl RemAssign<AutoSimd<[u32; 4]>> for AutoSimd<[u32; 4]>

impl RemAssign<AutoSimd<[u32; 8]>> for AutoSimd<[u32; 8]>

impl RemAssign<AutoSimd<[u32; 16]>> for AutoSimd<[u32; 16]>

impl RemAssign<AutoSimd<[u64; 2]>> for AutoSimd<[u64; 2]>

impl RemAssign<AutoSimd<[u64; 4]>> for AutoSimd<[u64; 4]>

impl RemAssign<AutoSimd<[u64; 8]>> for AutoSimd<[u64; 8]>

impl RemAssign<AutoSimd<[u8; 2]>> for AutoSimd<[u8; 2]>

impl RemAssign<AutoSimd<[u8; 4]>> for AutoSimd<[u8; 4]>

impl RemAssign<AutoSimd<[u8; 8]>> for AutoSimd<[u8; 8]>

impl RemAssign<AutoSimd<[u8; 16]>> for AutoSimd<[u8; 16]>

impl RemAssign<AutoSimd<[u8; 32]>> for AutoSimd<[u8; 32]>