Struct core::num::Saturating

#[repr(transparent)]
pub struct Saturating<T>(pub T);

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

在 T 上提供有意饱和的算法。

u32 值上的 + 之类的操作旨在永不溢出，并且在某些调试配置中，检测到溢出并导致 panic。 虽然大多数算术都属于这一类，但有些代码明确期望并依赖于饱和算术。

饱和算术可以通过像 saturating_add 这样的方法或通过 Saturating<T> 类型来实现，它表示对底层值的所有标准算术运算都旨在具有饱和语义。

可以通过 Saturating 元组的 .0 索引检索底层值。

Examples

#![feature(saturating_int_impl)]
use std::num::Saturating;

let max = Saturating(u32::MAX);
let one = Saturating(1u32);

assert_eq!(u32::MAX, (max + one).0);

Tuple Fields

0: T

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

Implementations

impl Saturating<usize>

pub const MIN: Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

返回此整数类型可以表示的最小值。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert_eq!(<Saturating<usize>>::MIN, Saturating(usize::MIN));

pub const MAX: Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

返回此整数类型可以表示的最大值。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert_eq!(<Saturating<usize>>::MAX, Saturating(usize::MAX));

pub const BITS: u32

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

以位为单位返回此整数类型的大小。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert_eq!(<Saturating<usize>>::BITS, usize::BITS);

pub const fn count_ones(self) -> u32

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

返回 self 二进制表示形式中的位数。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n = Saturating(0b01001100usize);

assert_eq!(n.count_ones(), 3);

pub const fn count_zeros(self) -> u32

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

返回 self 二进制表示形式中的零数。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert_eq!(Saturating(!0usize).count_zeros(), 0);

pub const fn trailing_zeros(self) -> u32

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

返回 self 二进制表示形式中的尾随零数。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n = Saturating(0b0101000usize);

assert_eq!(n.trailing_zeros(), 3);

pub const fn rotate_left(self, n: u32) -> Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

将位向左移动指定的量 n，将截断的位饱和到结果整数的末尾。

请注意，此操作与 << 移位运算符不同！

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n: Saturating<i64> = Saturating(0x0123456789ABCDEF);
let m: Saturating<i64> = Saturating(-0x76543210FEDCBA99);

assert_eq!(n.rotate_left(32), m);

pub const fn rotate_right(self, n: u32) -> Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

将位右移指定的量 n，将截断的位饱和到结果整数的开头。

请注意，此操作与 >> 移位运算符不同！

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n: Saturating<i64> = Saturating(0x0123456789ABCDEF);
let m: Saturating<i64> = Saturating(-0xFEDCBA987654322);

assert_eq!(n.rotate_right(4), m);

pub const fn swap_bytes(self) -> Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

反转整数的字节顺序。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n: Saturating<i16> = Saturating(0b0000000_01010101);
assert_eq!(n, Saturating(85));

let m = n.swap_bytes();

assert_eq!(m, Saturating(0b01010101_00000000));
assert_eq!(m, Saturating(21760));

pub fn reverse_bits(self) -> Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

反转整数的位模式。

Examples

请注意，此示例在整数类型之间共享。 这就解释了为什么在这里使用 i16。

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n = Saturating(0b0000000_01010101i16);
assert_eq!(n, Saturating(85));

let m = n.reverse_bits();

assert_eq!(m.0 as u16, 0b10101010_00000000);
assert_eq!(m, Saturating(-22016));

pub const fn from_be(x: Self) -> Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

将整数从大端字节序转换为目标的字节序。

在大端节序序上，这是个禁忌。 在小端字节序上，字节被交换。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n = Saturating(0x1Ausize);

if cfg!(target_endian = "big") {
    assert_eq!(<Saturating<usize>>::from_be(n), n)
} else {
    assert_eq!(<Saturating<usize>>::from_be(n), n.swap_bytes())
}

pub const fn from_le(x: Self) -> Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

将整数从小端字节序转换为目标的字节序。

在小端字节序上，这是个禁忌。 在大字节序中，字节被交换。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n = Saturating(0x1Ausize);

if cfg!(target_endian = "little") {
    assert_eq!(<Saturating<usize>>::from_le(n), n)
} else {
    assert_eq!(<Saturating<usize>>::from_le(n), n.swap_bytes())
}

pub const fn to_be(self) -> Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

将 self 从目标的字节序转换为大字节序。

在大端节序序上，这是个禁忌。 在小端字节序上，字节被交换。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n = Saturating(0x1Ausize);

if cfg!(target_endian = "big") {
    assert_eq!(n.to_be(), n)
} else {
    assert_eq!(n.to_be(), n.swap_bytes())
}

pub const fn to_le(self) -> Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

将 self 从目标的字节序转换为 Little Endian。

在小端字节序上，这是个禁忌。 在大字节序中，字节被交换。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n = Saturating(0x1Ausize);

if cfg!(target_endian = "little") {
    assert_eq!(n.to_le(), n)
} else {
    assert_eq!(n.to_le(), n.swap_bytes())
}

pub fn pow(self, exp: u32) -> Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

通过平方运算，将自己提升到 exp 的功效。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert_eq!(Saturating(3usize).pow(4), Saturating(81));

过大的结果是饱和的：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert_eq!(Saturating(3i8).pow(5), Saturating(127));
assert_eq!(Saturating(3i8).pow(6), Saturating(127));

impl Saturating<u8>

pub const MIN: Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

返回此整数类型可以表示的最小值。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert_eq!(<Saturating<u8>>::MIN, Saturating(u8::MIN));

pub const MAX: Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

返回此整数类型可以表示的最大值。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert_eq!(<Saturating<u8>>::MAX, Saturating(u8::MAX));

pub const BITS: u32

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

以位为单位返回此整数类型的大小。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert_eq!(<Saturating<u8>>::BITS, u8::BITS);

pub const fn count_ones(self) -> u32

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

返回 self 二进制表示形式中的位数。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n = Saturating(0b01001100u8);

assert_eq!(n.count_ones(), 3);

pub const fn count_zeros(self) -> u32

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

返回 self 二进制表示形式中的零数。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert_eq!(Saturating(!0u8).count_zeros(), 0);

pub const fn trailing_zeros(self) -> u32

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

返回 self 二进制表示形式中的尾随零数。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n = Saturating(0b0101000u8);

assert_eq!(n.trailing_zeros(), 3);

pub const fn rotate_left(self, n: u32) -> Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

将位向左移动指定的量 n，将截断的位饱和到结果整数的末尾。

请注意，此操作与 << 移位运算符不同！

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n: Saturating<i64> = Saturating(0x0123456789ABCDEF);
let m: Saturating<i64> = Saturating(-0x76543210FEDCBA99);

assert_eq!(n.rotate_left(32), m);

pub const fn rotate_right(self, n: u32) -> Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

将位右移指定的量 n，将截断的位饱和到结果整数的开头。

请注意，此操作与 >> 移位运算符不同！

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n: Saturating<i64> = Saturating(0x0123456789ABCDEF);
let m: Saturating<i64> = Saturating(-0xFEDCBA987654322);

assert_eq!(n.rotate_right(4), m);

pub const fn swap_bytes(self) -> Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

反转整数的字节顺序。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n: Saturating<i16> = Saturating(0b0000000_01010101);
assert_eq!(n, Saturating(85));

let m = n.swap_bytes();

assert_eq!(m, Saturating(0b01010101_00000000));
assert_eq!(m, Saturating(21760));

pub fn reverse_bits(self) -> Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

反转整数的位模式。

Examples

请注意，此示例在整数类型之间共享。 这就解释了为什么在这里使用 i16。

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n = Saturating(0b0000000_01010101i16);
assert_eq!(n, Saturating(85));

let m = n.reverse_bits();

assert_eq!(m.0 as u16, 0b10101010_00000000);
assert_eq!(m, Saturating(-22016));

pub const fn from_be(x: Self) -> Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

将整数从大端字节序转换为目标的字节序。

在大端节序序上，这是个禁忌。 在小端字节序上，字节被交换。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n = Saturating(0x1Au8);

if cfg!(target_endian = "big") {
    assert_eq!(<Saturating<u8>>::from_be(n), n)
} else {
    assert_eq!(<Saturating<u8>>::from_be(n), n.swap_bytes())
}

pub const fn from_le(x: Self) -> Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

将整数从小端字节序转换为目标的字节序。

在小端字节序上，这是个禁忌。 在大字节序中，字节被交换。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n = Saturating(0x1Au8);

if cfg!(target_endian = "little") {
    assert_eq!(<Saturating<u8>>::from_le(n), n)
} else {
    assert_eq!(<Saturating<u8>>::from_le(n), n.swap_bytes())
}

pub const fn to_be(self) -> Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

将 self 从目标的字节序转换为大字节序。

在大端节序序上，这是个禁忌。 在小端字节序上，字节被交换。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n = Saturating(0x1Au8);

if cfg!(target_endian = "big") {
    assert_eq!(n.to_be(), n)
} else {
    assert_eq!(n.to_be(), n.swap_bytes())
}

pub const fn to_le(self) -> Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

将 self 从目标的字节序转换为 Little Endian。

在小端字节序上，这是个禁忌。 在大字节序中，字节被交换。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n = Saturating(0x1Au8);

if cfg!(target_endian = "little") {
    assert_eq!(n.to_le(), n)
} else {
    assert_eq!(n.to_le(), n.swap_bytes())
}

pub fn pow(self, exp: u32) -> Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

通过平方运算，将自己提升到 exp 的功效。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert_eq!(Saturating(3u8).pow(4), Saturating(81));

过大的结果是饱和的：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert_eq!(Saturating(3i8).pow(5), Saturating(127));
assert_eq!(Saturating(3i8).pow(6), Saturating(127));

impl Saturating<u16>

pub const MIN: Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

返回此整数类型可以表示的最小值。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert_eq!(<Saturating<u16>>::MIN, Saturating(u16::MIN));

pub const MAX: Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

返回此整数类型可以表示的最大值。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert_eq!(<Saturating<u16>>::MAX, Saturating(u16::MAX));

pub const BITS: u32

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

以位为单位返回此整数类型的大小。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert_eq!(<Saturating<u16>>::BITS, u16::BITS);

pub const fn count_ones(self) -> u32

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

返回 self 二进制表示形式中的位数。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n = Saturating(0b01001100u16);

assert_eq!(n.count_ones(), 3);

pub const fn count_zeros(self) -> u32

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

返回 self 二进制表示形式中的零数。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert_eq!(Saturating(!0u16).count_zeros(), 0);

pub const fn trailing_zeros(self) -> u32

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

返回 self 二进制表示形式中的尾随零数。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n = Saturating(0b0101000u16);

assert_eq!(n.trailing_zeros(), 3);

pub const fn rotate_left(self, n: u32) -> Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

将位向左移动指定的量 n，将截断的位饱和到结果整数的末尾。

请注意，此操作与 << 移位运算符不同！

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n: Saturating<i64> = Saturating(0x0123456789ABCDEF);
let m: Saturating<i64> = Saturating(-0x76543210FEDCBA99);

assert_eq!(n.rotate_left(32), m);

pub const fn rotate_right(self, n: u32) -> Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

将位右移指定的量 n，将截断的位饱和到结果整数的开头。

请注意，此操作与 >> 移位运算符不同！

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n: Saturating<i64> = Saturating(0x0123456789ABCDEF);
let m: Saturating<i64> = Saturating(-0xFEDCBA987654322);

assert_eq!(n.rotate_right(4), m);

pub const fn swap_bytes(self) -> Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

反转整数的字节顺序。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n: Saturating<i16> = Saturating(0b0000000_01010101);
assert_eq!(n, Saturating(85));

let m = n.swap_bytes();

assert_eq!(m, Saturating(0b01010101_00000000));
assert_eq!(m, Saturating(21760));

pub fn reverse_bits(self) -> Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

反转整数的位模式。

Examples

请注意，此示例在整数类型之间共享。 这就解释了为什么在这里使用 i16。

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n = Saturating(0b0000000_01010101i16);
assert_eq!(n, Saturating(85));

let m = n.reverse_bits();

assert_eq!(m.0 as u16, 0b10101010_00000000);
assert_eq!(m, Saturating(-22016));

pub const fn from_be(x: Self) -> Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

将整数从大端字节序转换为目标的字节序。

在大端节序序上，这是个禁忌。 在小端字节序上，字节被交换。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n = Saturating(0x1Au16);

if cfg!(target_endian = "big") {
    assert_eq!(<Saturating<u16>>::from_be(n), n)
} else {
    assert_eq!(<Saturating<u16>>::from_be(n), n.swap_bytes())
}

pub const fn from_le(x: Self) -> Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

将整数从小端字节序转换为目标的字节序。

在小端字节序上，这是个禁忌。 在大字节序中，字节被交换。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n = Saturating(0x1Au16);

if cfg!(target_endian = "little") {
    assert_eq!(<Saturating<u16>>::from_le(n), n)
} else {
    assert_eq!(<Saturating<u16>>::from_le(n), n.swap_bytes())
}

pub const fn to_be(self) -> Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

将 self 从目标的字节序转换为大字节序。

在大端节序序上，这是个禁忌。 在小端字节序上，字节被交换。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n = Saturating(0x1Au16);

if cfg!(target_endian = "big") {
    assert_eq!(n.to_be(), n)
} else {
    assert_eq!(n.to_be(), n.swap_bytes())
}

pub const fn to_le(self) -> Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

将 self 从目标的字节序转换为 Little Endian。

在小端字节序上，这是个禁忌。 在大字节序中，字节被交换。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n = Saturating(0x1Au16);

if cfg!(target_endian = "little") {
    assert_eq!(n.to_le(), n)
} else {
    assert_eq!(n.to_le(), n.swap_bytes())
}

pub fn pow(self, exp: u32) -> Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

通过平方运算，将自己提升到 exp 的功效。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert_eq!(Saturating(3u16).pow(4), Saturating(81));

过大的结果是饱和的：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert_eq!(Saturating(3i8).pow(5), Saturating(127));
assert_eq!(Saturating(3i8).pow(6), Saturating(127));

impl Saturating<u32>

pub const MIN: Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

返回此整数类型可以表示的最小值。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert_eq!(<Saturating<u32>>::MIN, Saturating(u32::MIN));

pub const MAX: Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

返回此整数类型可以表示的最大值。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert_eq!(<Saturating<u32>>::MAX, Saturating(u32::MAX));

pub const BITS: u32

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

以位为单位返回此整数类型的大小。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert_eq!(<Saturating<u32>>::BITS, u32::BITS);

pub const fn count_ones(self) -> u32

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

返回 self 二进制表示形式中的位数。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n = Saturating(0b01001100u32);

assert_eq!(n.count_ones(), 3);

pub const fn count_zeros(self) -> u32

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

返回 self 二进制表示形式中的零数。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert_eq!(Saturating(!0u32).count_zeros(), 0);

pub const fn trailing_zeros(self) -> u32

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

返回 self 二进制表示形式中的尾随零数。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n = Saturating(0b0101000u32);

assert_eq!(n.trailing_zeros(), 3);

pub const fn rotate_left(self, n: u32) -> Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

将位向左移动指定的量 n，将截断的位饱和到结果整数的末尾。

请注意，此操作与 << 移位运算符不同！

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n: Saturating<i64> = Saturating(0x0123456789ABCDEF);
let m: Saturating<i64> = Saturating(-0x76543210FEDCBA99);

assert_eq!(n.rotate_left(32), m);

pub const fn rotate_right(self, n: u32) -> Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

将位右移指定的量 n，将截断的位饱和到结果整数的开头。

请注意，此操作与 >> 移位运算符不同！

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n: Saturating<i64> = Saturating(0x0123456789ABCDEF);
let m: Saturating<i64> = Saturating(-0xFEDCBA987654322);

assert_eq!(n.rotate_right(4), m);

pub const fn swap_bytes(self) -> Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

反转整数的字节顺序。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n: Saturating<i16> = Saturating(0b0000000_01010101);
assert_eq!(n, Saturating(85));

let m = n.swap_bytes();

assert_eq!(m, Saturating(0b01010101_00000000));
assert_eq!(m, Saturating(21760));

pub fn reverse_bits(self) -> Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

反转整数的位模式。

Examples

请注意，此示例在整数类型之间共享。 这就解释了为什么在这里使用 i16。

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n = Saturating(0b0000000_01010101i16);
assert_eq!(n, Saturating(85));

let m = n.reverse_bits();

assert_eq!(m.0 as u16, 0b10101010_00000000);
assert_eq!(m, Saturating(-22016));

pub const fn from_be(x: Self) -> Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

将整数从大端字节序转换为目标的字节序。

在大端节序序上，这是个禁忌。 在小端字节序上，字节被交换。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n = Saturating(0x1Au32);

if cfg!(target_endian = "big") {
    assert_eq!(<Saturating<u32>>::from_be(n), n)
} else {
    assert_eq!(<Saturating<u32>>::from_be(n), n.swap_bytes())
}

pub const fn from_le(x: Self) -> Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

将整数从小端字节序转换为目标的字节序。

在小端字节序上，这是个禁忌。 在大字节序中，字节被交换。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n = Saturating(0x1Au32);

if cfg!(target_endian = "little") {
    assert_eq!(<Saturating<u32>>::from_le(n), n)
} else {
    assert_eq!(<Saturating<u32>>::from_le(n), n.swap_bytes())
}

pub const fn to_be(self) -> Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

将 self 从目标的字节序转换为大字节序。

在大端节序序上，这是个禁忌。 在小端字节序上，字节被交换。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n = Saturating(0x1Au32);

if cfg!(target_endian = "big") {
    assert_eq!(n.to_be(), n)
} else {
    assert_eq!(n.to_be(), n.swap_bytes())
}

pub const fn to_le(self) -> Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

将 self 从目标的字节序转换为 Little Endian。

在小端字节序上，这是个禁忌。 在大字节序中，字节被交换。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n = Saturating(0x1Au32);

if cfg!(target_endian = "little") {
    assert_eq!(n.to_le(), n)
} else {
    assert_eq!(n.to_le(), n.swap_bytes())
}

pub fn pow(self, exp: u32) -> Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

通过平方运算，将自己提升到 exp 的功效。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert_eq!(Saturating(3u32).pow(4), Saturating(81));

过大的结果是饱和的：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert_eq!(Saturating(3i8).pow(5), Saturating(127));
assert_eq!(Saturating(3i8).pow(6), Saturating(127));

impl Saturating<u64>

pub const MIN: Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

返回此整数类型可以表示的最小值。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert_eq!(<Saturating<u64>>::MIN, Saturating(u64::MIN));

pub const MAX: Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

返回此整数类型可以表示的最大值。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert_eq!(<Saturating<u64>>::MAX, Saturating(u64::MAX));

pub const BITS: u32

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

以位为单位返回此整数类型的大小。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert_eq!(<Saturating<u64>>::BITS, u64::BITS);

pub const fn count_ones(self) -> u32

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

返回 self 二进制表示形式中的位数。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n = Saturating(0b01001100u64);

assert_eq!(n.count_ones(), 3);

pub const fn count_zeros(self) -> u32

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

返回 self 二进制表示形式中的零数。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert_eq!(Saturating(!0u64).count_zeros(), 0);

pub const fn trailing_zeros(self) -> u32

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

返回 self 二进制表示形式中的尾随零数。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n = Saturating(0b0101000u64);

assert_eq!(n.trailing_zeros(), 3);

pub const fn rotate_left(self, n: u32) -> Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

将位向左移动指定的量 n，将截断的位饱和到结果整数的末尾。

请注意，此操作与 << 移位运算符不同！

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n: Saturating<i64> = Saturating(0x0123456789ABCDEF);
let m: Saturating<i64> = Saturating(-0x76543210FEDCBA99);

assert_eq!(n.rotate_left(32), m);

pub const fn rotate_right(self, n: u32) -> Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

将位右移指定的量 n，将截断的位饱和到结果整数的开头。

请注意，此操作与 >> 移位运算符不同！

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n: Saturating<i64> = Saturating(0x0123456789ABCDEF);
let m: Saturating<i64> = Saturating(-0xFEDCBA987654322);

assert_eq!(n.rotate_right(4), m);

pub const fn swap_bytes(self) -> Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

反转整数的字节顺序。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n: Saturating<i16> = Saturating(0b0000000_01010101);
assert_eq!(n, Saturating(85));

let m = n.swap_bytes();

assert_eq!(m, Saturating(0b01010101_00000000));
assert_eq!(m, Saturating(21760));

pub fn reverse_bits(self) -> Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

反转整数的位模式。

Examples

请注意，此示例在整数类型之间共享。 这就解释了为什么在这里使用 i16。

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n = Saturating(0b0000000_01010101i16);
assert_eq!(n, Saturating(85));

let m = n.reverse_bits();

assert_eq!(m.0 as u16, 0b10101010_00000000);
assert_eq!(m, Saturating(-22016));

pub const fn from_be(x: Self) -> Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

将整数从大端字节序转换为目标的字节序。

在大端节序序上，这是个禁忌。 在小端字节序上，字节被交换。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n = Saturating(0x1Au64);

if cfg!(target_endian = "big") {
    assert_eq!(<Saturating<u64>>::from_be(n), n)
} else {
    assert_eq!(<Saturating<u64>>::from_be(n), n.swap_bytes())
}

pub const fn from_le(x: Self) -> Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

将整数从小端字节序转换为目标的字节序。

在小端字节序上，这是个禁忌。 在大字节序中，字节被交换。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n = Saturating(0x1Au64);

if cfg!(target_endian = "little") {
    assert_eq!(<Saturating<u64>>::from_le(n), n)
} else {
    assert_eq!(<Saturating<u64>>::from_le(n), n.swap_bytes())
}

pub const fn to_be(self) -> Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

将 self 从目标的字节序转换为大字节序。

在大端节序序上，这是个禁忌。 在小端字节序上，字节被交换。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n = Saturating(0x1Au64);

if cfg!(target_endian = "big") {
    assert_eq!(n.to_be(), n)
} else {
    assert_eq!(n.to_be(), n.swap_bytes())
}

pub const fn to_le(self) -> Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

将 self 从目标的字节序转换为 Little Endian。

在小端字节序上，这是个禁忌。 在大字节序中，字节被交换。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n = Saturating(0x1Au64);

if cfg!(target_endian = "little") {
    assert_eq!(n.to_le(), n)
} else {
    assert_eq!(n.to_le(), n.swap_bytes())
}

pub fn pow(self, exp: u32) -> Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

通过平方运算，将自己提升到 exp 的功效。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert_eq!(Saturating(3u64).pow(4), Saturating(81));

过大的结果是饱和的：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert_eq!(Saturating(3i8).pow(5), Saturating(127));
assert_eq!(Saturating(3i8).pow(6), Saturating(127));

impl Saturating<u128>

pub const MIN: Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

返回此整数类型可以表示的最小值。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert_eq!(<Saturating<u128>>::MIN, Saturating(u128::MIN));

pub const MAX: Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

返回此整数类型可以表示的最大值。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert_eq!(<Saturating<u128>>::MAX, Saturating(u128::MAX));

pub const BITS: u32

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

以位为单位返回此整数类型的大小。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert_eq!(<Saturating<u128>>::BITS, u128::BITS);

pub const fn count_ones(self) -> u32

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

返回 self 二进制表示形式中的位数。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n = Saturating(0b01001100u128);

assert_eq!(n.count_ones(), 3);

pub const fn count_zeros(self) -> u32

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

返回 self 二进制表示形式中的零数。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert_eq!(Saturating(!0u128).count_zeros(), 0);

pub const fn trailing_zeros(self) -> u32

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

返回 self 二进制表示形式中的尾随零数。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n = Saturating(0b0101000u128);

assert_eq!(n.trailing_zeros(), 3);

pub const fn rotate_left(self, n: u32) -> Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

将位向左移动指定的量 n，将截断的位饱和到结果整数的末尾。

请注意，此操作与 << 移位运算符不同！

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n: Saturating<i64> = Saturating(0x0123456789ABCDEF);
let m: Saturating<i64> = Saturating(-0x76543210FEDCBA99);

assert_eq!(n.rotate_left(32), m);

pub const fn rotate_right(self, n: u32) -> Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

将位右移指定的量 n，将截断的位饱和到结果整数的开头。

请注意，此操作与 >> 移位运算符不同！

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n: Saturating<i64> = Saturating(0x0123456789ABCDEF);
let m: Saturating<i64> = Saturating(-0xFEDCBA987654322);

assert_eq!(n.rotate_right(4), m);

pub const fn swap_bytes(self) -> Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

反转整数的字节顺序。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n: Saturating<i16> = Saturating(0b0000000_01010101);
assert_eq!(n, Saturating(85));

let m = n.swap_bytes();

assert_eq!(m, Saturating(0b01010101_00000000));
assert_eq!(m, Saturating(21760));

pub fn reverse_bits(self) -> Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

反转整数的位模式。

Examples

请注意，此示例在整数类型之间共享。 这就解释了为什么在这里使用 i16。

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n = Saturating(0b0000000_01010101i16);
assert_eq!(n, Saturating(85));

let m = n.reverse_bits();

assert_eq!(m.0 as u16, 0b10101010_00000000);
assert_eq!(m, Saturating(-22016));

pub const fn from_be(x: Self) -> Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

将整数从大端字节序转换为目标的字节序。

在大端节序序上，这是个禁忌。 在小端字节序上，字节被交换。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n = Saturating(0x1Au128);

if cfg!(target_endian = "big") {
    assert_eq!(<Saturating<u128>>::from_be(n), n)
} else {
    assert_eq!(<Saturating<u128>>::from_be(n), n.swap_bytes())
}

pub const fn from_le(x: Self) -> Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

将整数从小端字节序转换为目标的字节序。

在小端字节序上，这是个禁忌。 在大字节序中，字节被交换。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n = Saturating(0x1Au128);

if cfg!(target_endian = "little") {
    assert_eq!(<Saturating<u128>>::from_le(n), n)
} else {
    assert_eq!(<Saturating<u128>>::from_le(n), n.swap_bytes())
}

pub const fn to_be(self) -> Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

将 self 从目标的字节序转换为大字节序。

在大端节序序上，这是个禁忌。 在小端字节序上，字节被交换。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n = Saturating(0x1Au128);

if cfg!(target_endian = "big") {
    assert_eq!(n.to_be(), n)
} else {
    assert_eq!(n.to_be(), n.swap_bytes())
}

pub const fn to_le(self) -> Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

将 self 从目标的字节序转换为 Little Endian。

在小端字节序上，这是个禁忌。 在大字节序中，字节被交换。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n = Saturating(0x1Au128);

if cfg!(target_endian = "little") {
    assert_eq!(n.to_le(), n)
} else {
    assert_eq!(n.to_le(), n.swap_bytes())
}

pub fn pow(self, exp: u32) -> Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

通过平方运算，将自己提升到 exp 的功效。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert_eq!(Saturating(3u128).pow(4), Saturating(81));

过大的结果是饱和的：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert_eq!(Saturating(3i8).pow(5), Saturating(127));
assert_eq!(Saturating(3i8).pow(6), Saturating(127));

impl Saturating<isize>

pub const MIN: Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

返回此整数类型可以表示的最小值。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert_eq!(<Saturating<isize>>::MIN, Saturating(isize::MIN));

pub const MAX: Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

返回此整数类型可以表示的最大值。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert_eq!(<Saturating<isize>>::MAX, Saturating(isize::MAX));

pub const BITS: u32

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

以位为单位返回此整数类型的大小。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert_eq!(<Saturating<isize>>::BITS, isize::BITS);

pub const fn count_ones(self) -> u32

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

返回 self 二进制表示形式中的位数。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n = Saturating(0b01001100isize);

assert_eq!(n.count_ones(), 3);

pub const fn count_zeros(self) -> u32

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

返回 self 二进制表示形式中的零数。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert_eq!(Saturating(!0isize).count_zeros(), 0);

pub const fn trailing_zeros(self) -> u32

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

返回 self 二进制表示形式中的尾随零数。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n = Saturating(0b0101000isize);

assert_eq!(n.trailing_zeros(), 3);

pub const fn rotate_left(self, n: u32) -> Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

将位向左移动指定的量 n，将截断的位饱和到结果整数的末尾。

请注意，此操作与 << 移位运算符不同！

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n: Saturating<i64> = Saturating(0x0123456789ABCDEF);
let m: Saturating<i64> = Saturating(-0x76543210FEDCBA99);

assert_eq!(n.rotate_left(32), m);

pub const fn rotate_right(self, n: u32) -> Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

将位右移指定的量 n，将截断的位饱和到结果整数的开头。

请注意，此操作与 >> 移位运算符不同！

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n: Saturating<i64> = Saturating(0x0123456789ABCDEF);
let m: Saturating<i64> = Saturating(-0xFEDCBA987654322);

assert_eq!(n.rotate_right(4), m);

pub const fn swap_bytes(self) -> Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

反转整数的字节顺序。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n: Saturating<i16> = Saturating(0b0000000_01010101);
assert_eq!(n, Saturating(85));

let m = n.swap_bytes();

assert_eq!(m, Saturating(0b01010101_00000000));
assert_eq!(m, Saturating(21760));

pub fn reverse_bits(self) -> Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

反转整数的位模式。

Examples

请注意，此示例在整数类型之间共享。 这就解释了为什么在这里使用 i16。

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n = Saturating(0b0000000_01010101i16);
assert_eq!(n, Saturating(85));

let m = n.reverse_bits();

assert_eq!(m.0 as u16, 0b10101010_00000000);
assert_eq!(m, Saturating(-22016));

pub const fn from_be(x: Self) -> Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

将整数从大端字节序转换为目标的字节序。

在大端节序序上，这是个禁忌。 在小端字节序上，字节被交换。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n = Saturating(0x1Aisize);

if cfg!(target_endian = "big") {
    assert_eq!(<Saturating<isize>>::from_be(n), n)
} else {
    assert_eq!(<Saturating<isize>>::from_be(n), n.swap_bytes())
}

pub const fn from_le(x: Self) -> Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

将整数从小端字节序转换为目标的字节序。

在小端字节序上，这是个禁忌。 在大字节序中，字节被交换。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n = Saturating(0x1Aisize);

if cfg!(target_endian = "little") {
    assert_eq!(<Saturating<isize>>::from_le(n), n)
} else {
    assert_eq!(<Saturating<isize>>::from_le(n), n.swap_bytes())
}

pub const fn to_be(self) -> Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

将 self 从目标的字节序转换为大字节序。

在大端节序序上，这是个禁忌。 在小端字节序上，字节被交换。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n = Saturating(0x1Aisize);

if cfg!(target_endian = "big") {
    assert_eq!(n.to_be(), n)
} else {
    assert_eq!(n.to_be(), n.swap_bytes())
}

pub const fn to_le(self) -> Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

将 self 从目标的字节序转换为 Little Endian。

在小端字节序上，这是个禁忌。 在大字节序中，字节被交换。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n = Saturating(0x1Aisize);

if cfg!(target_endian = "little") {
    assert_eq!(n.to_le(), n)
} else {
    assert_eq!(n.to_le(), n.swap_bytes())
}

pub fn pow(self, exp: u32) -> Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

通过平方运算，将自己提升到 exp 的功效。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert_eq!(Saturating(3isize).pow(4), Saturating(81));

过大的结果是饱和的：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert_eq!(Saturating(3i8).pow(5), Saturating(127));
assert_eq!(Saturating(3i8).pow(6), Saturating(127));

impl Saturating<i8>

pub const MIN: Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

返回此整数类型可以表示的最小值。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert_eq!(<Saturating<i8>>::MIN, Saturating(i8::MIN));

pub const MAX: Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

返回此整数类型可以表示的最大值。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert_eq!(<Saturating<i8>>::MAX, Saturating(i8::MAX));

pub const BITS: u32

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

以位为单位返回此整数类型的大小。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert_eq!(<Saturating<i8>>::BITS, i8::BITS);

pub const fn count_ones(self) -> u32

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

返回 self 二进制表示形式中的位数。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n = Saturating(0b01001100i8);

assert_eq!(n.count_ones(), 3);

pub const fn count_zeros(self) -> u32

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

返回 self 二进制表示形式中的零数。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert_eq!(Saturating(!0i8).count_zeros(), 0);

pub const fn trailing_zeros(self) -> u32

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

返回 self 二进制表示形式中的尾随零数。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n = Saturating(0b0101000i8);

assert_eq!(n.trailing_zeros(), 3);

pub const fn rotate_left(self, n: u32) -> Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

将位向左移动指定的量 n，将截断的位饱和到结果整数的末尾。

请注意，此操作与 << 移位运算符不同！

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n: Saturating<i64> = Saturating(0x0123456789ABCDEF);
let m: Saturating<i64> = Saturating(-0x76543210FEDCBA99);

assert_eq!(n.rotate_left(32), m);

pub const fn rotate_right(self, n: u32) -> Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

将位右移指定的量 n，将截断的位饱和到结果整数的开头。

请注意，此操作与 >> 移位运算符不同！

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n: Saturating<i64> = Saturating(0x0123456789ABCDEF);
let m: Saturating<i64> = Saturating(-0xFEDCBA987654322);

assert_eq!(n.rotate_right(4), m);

pub const fn swap_bytes(self) -> Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

反转整数的字节顺序。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n: Saturating<i16> = Saturating(0b0000000_01010101);
assert_eq!(n, Saturating(85));

let m = n.swap_bytes();

assert_eq!(m, Saturating(0b01010101_00000000));
assert_eq!(m, Saturating(21760));

pub fn reverse_bits(self) -> Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

反转整数的位模式。

Examples

请注意，此示例在整数类型之间共享。 这就解释了为什么在这里使用 i16。

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n = Saturating(0b0000000_01010101i16);
assert_eq!(n, Saturating(85));

let m = n.reverse_bits();

assert_eq!(m.0 as u16, 0b10101010_00000000);
assert_eq!(m, Saturating(-22016));

pub const fn from_be(x: Self) -> Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

将整数从大端字节序转换为目标的字节序。

在大端节序序上，这是个禁忌。 在小端字节序上，字节被交换。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n = Saturating(0x1Ai8);

if cfg!(target_endian = "big") {
    assert_eq!(<Saturating<i8>>::from_be(n), n)
} else {
    assert_eq!(<Saturating<i8>>::from_be(n), n.swap_bytes())
}

pub const fn from_le(x: Self) -> Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

将整数从小端字节序转换为目标的字节序。

在小端字节序上，这是个禁忌。 在大字节序中，字节被交换。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n = Saturating(0x1Ai8);

if cfg!(target_endian = "little") {
    assert_eq!(<Saturating<i8>>::from_le(n), n)
} else {
    assert_eq!(<Saturating<i8>>::from_le(n), n.swap_bytes())
}

pub const fn to_be(self) -> Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

将 self 从目标的字节序转换为大字节序。

在大端节序序上，这是个禁忌。 在小端字节序上，字节被交换。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n = Saturating(0x1Ai8);

if cfg!(target_endian = "big") {
    assert_eq!(n.to_be(), n)
} else {
    assert_eq!(n.to_be(), n.swap_bytes())
}

pub const fn to_le(self) -> Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

将 self 从目标的字节序转换为 Little Endian。

在小端字节序上，这是个禁忌。 在大字节序中，字节被交换。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n = Saturating(0x1Ai8);

if cfg!(target_endian = "little") {
    assert_eq!(n.to_le(), n)
} else {
    assert_eq!(n.to_le(), n.swap_bytes())
}

pub fn pow(self, exp: u32) -> Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

通过平方运算，将自己提升到 exp 的功效。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert_eq!(Saturating(3i8).pow(4), Saturating(81));

过大的结果是饱和的：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert_eq!(Saturating(3i8).pow(5), Saturating(127));
assert_eq!(Saturating(3i8).pow(6), Saturating(127));

impl Saturating<i16>

pub const MIN: Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

返回此整数类型可以表示的最小值。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert_eq!(<Saturating<i16>>::MIN, Saturating(i16::MIN));

pub const MAX: Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

返回此整数类型可以表示的最大值。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert_eq!(<Saturating<i16>>::MAX, Saturating(i16::MAX));

pub const BITS: u32

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

以位为单位返回此整数类型的大小。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert_eq!(<Saturating<i16>>::BITS, i16::BITS);

pub const fn count_ones(self) -> u32

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

返回 self 二进制表示形式中的位数。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n = Saturating(0b01001100i16);

assert_eq!(n.count_ones(), 3);

pub const fn count_zeros(self) -> u32

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

返回 self 二进制表示形式中的零数。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert_eq!(Saturating(!0i16).count_zeros(), 0);

pub const fn trailing_zeros(self) -> u32

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

返回 self 二进制表示形式中的尾随零数。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n = Saturating(0b0101000i16);

assert_eq!(n.trailing_zeros(), 3);

pub const fn rotate_left(self, n: u32) -> Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

将位向左移动指定的量 n，将截断的位饱和到结果整数的末尾。

请注意，此操作与 << 移位运算符不同！

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n: Saturating<i64> = Saturating(0x0123456789ABCDEF);
let m: Saturating<i64> = Saturating(-0x76543210FEDCBA99);

assert_eq!(n.rotate_left(32), m);

pub const fn rotate_right(self, n: u32) -> Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

将位右移指定的量 n，将截断的位饱和到结果整数的开头。

请注意，此操作与 >> 移位运算符不同！

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n: Saturating<i64> = Saturating(0x0123456789ABCDEF);
let m: Saturating<i64> = Saturating(-0xFEDCBA987654322);

assert_eq!(n.rotate_right(4), m);

pub const fn swap_bytes(self) -> Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

反转整数的字节顺序。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n: Saturating<i16> = Saturating(0b0000000_01010101);
assert_eq!(n, Saturating(85));

let m = n.swap_bytes();

assert_eq!(m, Saturating(0b01010101_00000000));
assert_eq!(m, Saturating(21760));

pub fn reverse_bits(self) -> Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

反转整数的位模式。

Examples

请注意，此示例在整数类型之间共享。 这就解释了为什么在这里使用 i16。

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n = Saturating(0b0000000_01010101i16);
assert_eq!(n, Saturating(85));

let m = n.reverse_bits();

assert_eq!(m.0 as u16, 0b10101010_00000000);
assert_eq!(m, Saturating(-22016));

pub const fn from_be(x: Self) -> Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

将整数从大端字节序转换为目标的字节序。

在大端节序序上，这是个禁忌。 在小端字节序上，字节被交换。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n = Saturating(0x1Ai16);

if cfg!(target_endian = "big") {
    assert_eq!(<Saturating<i16>>::from_be(n), n)
} else {
    assert_eq!(<Saturating<i16>>::from_be(n), n.swap_bytes())
}

pub const fn from_le(x: Self) -> Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

将整数从小端字节序转换为目标的字节序。

在小端字节序上，这是个禁忌。 在大字节序中，字节被交换。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n = Saturating(0x1Ai16);

if cfg!(target_endian = "little") {
    assert_eq!(<Saturating<i16>>::from_le(n), n)
} else {
    assert_eq!(<Saturating<i16>>::from_le(n), n.swap_bytes())
}

pub const fn to_be(self) -> Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

将 self 从目标的字节序转换为大字节序。

在大端节序序上，这是个禁忌。 在小端字节序上，字节被交换。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n = Saturating(0x1Ai16);

if cfg!(target_endian = "big") {
    assert_eq!(n.to_be(), n)
} else {
    assert_eq!(n.to_be(), n.swap_bytes())
}

pub const fn to_le(self) -> Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

将 self 从目标的字节序转换为 Little Endian。

在小端字节序上，这是个禁忌。 在大字节序中，字节被交换。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n = Saturating(0x1Ai16);

if cfg!(target_endian = "little") {
    assert_eq!(n.to_le(), n)
} else {
    assert_eq!(n.to_le(), n.swap_bytes())
}

pub fn pow(self, exp: u32) -> Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

通过平方运算，将自己提升到 exp 的功效。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert_eq!(Saturating(3i16).pow(4), Saturating(81));

过大的结果是饱和的：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert_eq!(Saturating(3i8).pow(5), Saturating(127));
assert_eq!(Saturating(3i8).pow(6), Saturating(127));

impl Saturating<i32>

pub const MIN: Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

返回此整数类型可以表示的最小值。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert_eq!(<Saturating<i32>>::MIN, Saturating(i32::MIN));

pub const MAX: Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

返回此整数类型可以表示的最大值。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert_eq!(<Saturating<i32>>::MAX, Saturating(i32::MAX));

pub const BITS: u32

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

以位为单位返回此整数类型的大小。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert_eq!(<Saturating<i32>>::BITS, i32::BITS);

pub const fn count_ones(self) -> u32

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

返回 self 二进制表示形式中的位数。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n = Saturating(0b01001100i32);

assert_eq!(n.count_ones(), 3);

pub const fn count_zeros(self) -> u32

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

返回 self 二进制表示形式中的零数。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert_eq!(Saturating(!0i32).count_zeros(), 0);

pub const fn trailing_zeros(self) -> u32

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

返回 self 二进制表示形式中的尾随零数。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n = Saturating(0b0101000i32);

assert_eq!(n.trailing_zeros(), 3);

pub const fn rotate_left(self, n: u32) -> Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

将位向左移动指定的量 n，将截断的位饱和到结果整数的末尾。

请注意，此操作与 << 移位运算符不同！

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n: Saturating<i64> = Saturating(0x0123456789ABCDEF);
let m: Saturating<i64> = Saturating(-0x76543210FEDCBA99);

assert_eq!(n.rotate_left(32), m);

pub const fn rotate_right(self, n: u32) -> Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

将位右移指定的量 n，将截断的位饱和到结果整数的开头。

请注意，此操作与 >> 移位运算符不同！

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n: Saturating<i64> = Saturating(0x0123456789ABCDEF);
let m: Saturating<i64> = Saturating(-0xFEDCBA987654322);

assert_eq!(n.rotate_right(4), m);

pub const fn swap_bytes(self) -> Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

反转整数的字节顺序。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n: Saturating<i16> = Saturating(0b0000000_01010101);
assert_eq!(n, Saturating(85));

let m = n.swap_bytes();

assert_eq!(m, Saturating(0b01010101_00000000));
assert_eq!(m, Saturating(21760));

pub fn reverse_bits(self) -> Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

反转整数的位模式。

Examples

请注意，此示例在整数类型之间共享。 这就解释了为什么在这里使用 i16。

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n = Saturating(0b0000000_01010101i16);
assert_eq!(n, Saturating(85));

let m = n.reverse_bits();

assert_eq!(m.0 as u16, 0b10101010_00000000);
assert_eq!(m, Saturating(-22016));

pub const fn from_be(x: Self) -> Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

将整数从大端字节序转换为目标的字节序。

在大端节序序上，这是个禁忌。 在小端字节序上，字节被交换。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n = Saturating(0x1Ai32);

if cfg!(target_endian = "big") {
    assert_eq!(<Saturating<i32>>::from_be(n), n)
} else {
    assert_eq!(<Saturating<i32>>::from_be(n), n.swap_bytes())
}

pub const fn from_le(x: Self) -> Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

将整数从小端字节序转换为目标的字节序。

在小端字节序上，这是个禁忌。 在大字节序中，字节被交换。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n = Saturating(0x1Ai32);

if cfg!(target_endian = "little") {
    assert_eq!(<Saturating<i32>>::from_le(n), n)
} else {
    assert_eq!(<Saturating<i32>>::from_le(n), n.swap_bytes())
}

pub const fn to_be(self) -> Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

将 self 从目标的字节序转换为大字节序。

在大端节序序上，这是个禁忌。 在小端字节序上，字节被交换。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n = Saturating(0x1Ai32);

if cfg!(target_endian = "big") {
    assert_eq!(n.to_be(), n)
} else {
    assert_eq!(n.to_be(), n.swap_bytes())
}

pub const fn to_le(self) -> Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

将 self 从目标的字节序转换为 Little Endian。

在小端字节序上，这是个禁忌。 在大字节序中，字节被交换。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n = Saturating(0x1Ai32);

if cfg!(target_endian = "little") {
    assert_eq!(n.to_le(), n)
} else {
    assert_eq!(n.to_le(), n.swap_bytes())
}

pub fn pow(self, exp: u32) -> Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

通过平方运算，将自己提升到 exp 的功效。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert_eq!(Saturating(3i32).pow(4), Saturating(81));

过大的结果是饱和的：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert_eq!(Saturating(3i8).pow(5), Saturating(127));
assert_eq!(Saturating(3i8).pow(6), Saturating(127));

impl Saturating<i64>

pub const MIN: Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

返回此整数类型可以表示的最小值。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert_eq!(<Saturating<i64>>::MIN, Saturating(i64::MIN));

pub const MAX: Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

返回此整数类型可以表示的最大值。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert_eq!(<Saturating<i64>>::MAX, Saturating(i64::MAX));

pub const BITS: u32

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

以位为单位返回此整数类型的大小。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert_eq!(<Saturating<i64>>::BITS, i64::BITS);

pub const fn count_ones(self) -> u32

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

返回 self 二进制表示形式中的位数。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n = Saturating(0b01001100i64);

assert_eq!(n.count_ones(), 3);

pub const fn count_zeros(self) -> u32

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

返回 self 二进制表示形式中的零数。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert_eq!(Saturating(!0i64).count_zeros(), 0);

pub const fn trailing_zeros(self) -> u32

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

返回 self 二进制表示形式中的尾随零数。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n = Saturating(0b0101000i64);

assert_eq!(n.trailing_zeros(), 3);

pub const fn rotate_left(self, n: u32) -> Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

将位向左移动指定的量 n，将截断的位饱和到结果整数的末尾。

请注意，此操作与 << 移位运算符不同！

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n: Saturating<i64> = Saturating(0x0123456789ABCDEF);
let m: Saturating<i64> = Saturating(-0x76543210FEDCBA99);

assert_eq!(n.rotate_left(32), m);

pub const fn rotate_right(self, n: u32) -> Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

将位右移指定的量 n，将截断的位饱和到结果整数的开头。

请注意，此操作与 >> 移位运算符不同！

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n: Saturating<i64> = Saturating(0x0123456789ABCDEF);
let m: Saturating<i64> = Saturating(-0xFEDCBA987654322);

assert_eq!(n.rotate_right(4), m);

pub const fn swap_bytes(self) -> Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

反转整数的字节顺序。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n: Saturating<i16> = Saturating(0b0000000_01010101);
assert_eq!(n, Saturating(85));

let m = n.swap_bytes();

assert_eq!(m, Saturating(0b01010101_00000000));
assert_eq!(m, Saturating(21760));

pub fn reverse_bits(self) -> Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

反转整数的位模式。

Examples

请注意，此示例在整数类型之间共享。 这就解释了为什么在这里使用 i16。

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n = Saturating(0b0000000_01010101i16);
assert_eq!(n, Saturating(85));

let m = n.reverse_bits();

assert_eq!(m.0 as u16, 0b10101010_00000000);
assert_eq!(m, Saturating(-22016));

pub const fn from_be(x: Self) -> Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

将整数从大端字节序转换为目标的字节序。

在大端节序序上，这是个禁忌。 在小端字节序上，字节被交换。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n = Saturating(0x1Ai64);

if cfg!(target_endian = "big") {
    assert_eq!(<Saturating<i64>>::from_be(n), n)
} else {
    assert_eq!(<Saturating<i64>>::from_be(n), n.swap_bytes())
}

pub const fn from_le(x: Self) -> Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

将整数从小端字节序转换为目标的字节序。

在小端字节序上，这是个禁忌。 在大字节序中，字节被交换。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n = Saturating(0x1Ai64);

if cfg!(target_endian = "little") {
    assert_eq!(<Saturating<i64>>::from_le(n), n)
} else {
    assert_eq!(<Saturating<i64>>::from_le(n), n.swap_bytes())
}

pub const fn to_be(self) -> Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

将 self 从目标的字节序转换为大字节序。

在大端节序序上，这是个禁忌。 在小端字节序上，字节被交换。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n = Saturating(0x1Ai64);

if cfg!(target_endian = "big") {
    assert_eq!(n.to_be(), n)
} else {
    assert_eq!(n.to_be(), n.swap_bytes())
}

pub const fn to_le(self) -> Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

将 self 从目标的字节序转换为 Little Endian。

在小端字节序上，这是个禁忌。 在大字节序中，字节被交换。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n = Saturating(0x1Ai64);

if cfg!(target_endian = "little") {
    assert_eq!(n.to_le(), n)
} else {
    assert_eq!(n.to_le(), n.swap_bytes())
}

pub fn pow(self, exp: u32) -> Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

通过平方运算，将自己提升到 exp 的功效。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert_eq!(Saturating(3i64).pow(4), Saturating(81));

过大的结果是饱和的：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert_eq!(Saturating(3i8).pow(5), Saturating(127));
assert_eq!(Saturating(3i8).pow(6), Saturating(127));

impl Saturating<i128>

pub const MIN: Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

返回此整数类型可以表示的最小值。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert_eq!(<Saturating<i128>>::MIN, Saturating(i128::MIN));

pub const MAX: Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

返回此整数类型可以表示的最大值。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert_eq!(<Saturating<i128>>::MAX, Saturating(i128::MAX));

pub const BITS: u32

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

以位为单位返回此整数类型的大小。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert_eq!(<Saturating<i128>>::BITS, i128::BITS);

pub const fn count_ones(self) -> u32

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

返回 self 二进制表示形式中的位数。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n = Saturating(0b01001100i128);

assert_eq!(n.count_ones(), 3);

pub const fn count_zeros(self) -> u32

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

返回 self 二进制表示形式中的零数。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert_eq!(Saturating(!0i128).count_zeros(), 0);

pub const fn trailing_zeros(self) -> u32

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

返回 self 二进制表示形式中的尾随零数。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n = Saturating(0b0101000i128);

assert_eq!(n.trailing_zeros(), 3);

pub const fn rotate_left(self, n: u32) -> Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

将位向左移动指定的量 n，将截断的位饱和到结果整数的末尾。

请注意，此操作与 << 移位运算符不同！

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n: Saturating<i64> = Saturating(0x0123456789ABCDEF);
let m: Saturating<i64> = Saturating(-0x76543210FEDCBA99);

assert_eq!(n.rotate_left(32), m);

pub const fn rotate_right(self, n: u32) -> Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

将位右移指定的量 n，将截断的位饱和到结果整数的开头。

请注意，此操作与 >> 移位运算符不同！

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n: Saturating<i64> = Saturating(0x0123456789ABCDEF);
let m: Saturating<i64> = Saturating(-0xFEDCBA987654322);

assert_eq!(n.rotate_right(4), m);

pub const fn swap_bytes(self) -> Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

反转整数的字节顺序。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n: Saturating<i16> = Saturating(0b0000000_01010101);
assert_eq!(n, Saturating(85));

let m = n.swap_bytes();

assert_eq!(m, Saturating(0b01010101_00000000));
assert_eq!(m, Saturating(21760));

pub fn reverse_bits(self) -> Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

反转整数的位模式。

Examples

请注意，此示例在整数类型之间共享。 这就解释了为什么在这里使用 i16。

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n = Saturating(0b0000000_01010101i16);
assert_eq!(n, Saturating(85));

let m = n.reverse_bits();

assert_eq!(m.0 as u16, 0b10101010_00000000);
assert_eq!(m, Saturating(-22016));

pub const fn from_be(x: Self) -> Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

将整数从大端字节序转换为目标的字节序。

在大端节序序上，这是个禁忌。 在小端字节序上，字节被交换。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n = Saturating(0x1Ai128);

if cfg!(target_endian = "big") {
    assert_eq!(<Saturating<i128>>::from_be(n), n)
} else {
    assert_eq!(<Saturating<i128>>::from_be(n), n.swap_bytes())
}

pub const fn from_le(x: Self) -> Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

将整数从小端字节序转换为目标的字节序。

在小端字节序上，这是个禁忌。 在大字节序中，字节被交换。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n = Saturating(0x1Ai128);

if cfg!(target_endian = "little") {
    assert_eq!(<Saturating<i128>>::from_le(n), n)
} else {
    assert_eq!(<Saturating<i128>>::from_le(n), n.swap_bytes())
}

pub const fn to_be(self) -> Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

将 self 从目标的字节序转换为大字节序。

在大端节序序上，这是个禁忌。 在小端字节序上，字节被交换。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n = Saturating(0x1Ai128);

if cfg!(target_endian = "big") {
    assert_eq!(n.to_be(), n)
} else {
    assert_eq!(n.to_be(), n.swap_bytes())
}

pub const fn to_le(self) -> Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

将 self 从目标的字节序转换为 Little Endian。

在小端字节序上，这是个禁忌。 在大字节序中，字节被交换。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n = Saturating(0x1Ai128);

if cfg!(target_endian = "little") {
    assert_eq!(n.to_le(), n)
} else {
    assert_eq!(n.to_le(), n.swap_bytes())
}

pub fn pow(self, exp: u32) -> Self

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

通过平方运算，将自己提升到 exp 的功效。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert_eq!(Saturating(3i128).pow(4), Saturating(81));

过大的结果是饱和的：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert_eq!(Saturating(3i8).pow(5), Saturating(127));
assert_eq!(Saturating(3i8).pow(6), Saturating(127));

impl Saturating<isize>

pub const fn leading_zeros(self) -> u32

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

返回 self 二进制表示形式中前导零的数目。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n = Saturating(isize::MAX >> 2);

assert_eq!(n.leading_zeros(), 3);

pub fn abs(self) -> Saturating<isize>

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

饱和绝对值。 计算 self.abs()，如果 self == MIN 则返回 MAX 而不是溢出。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert_eq!(Saturating(100isize).abs(), Saturating(100));
assert_eq!(Saturating(-100isize).abs(), Saturating(100));
assert_eq!(Saturating(isize::MIN).abs(), Saturating((isize::MIN + 1).abs()));
assert_eq!(Saturating(isize::MIN).abs(), Saturating(isize::MIN.saturating_abs()));
assert_eq!(Saturating(isize::MIN).abs(), Saturating(isize::MAX));

pub fn signum(self) -> Saturating<isize>

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

返回一个表示 self 的符号的数字。

• 0 如果数字为零
• 1 如果数字是正数
• -1 如果数字是负数

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert_eq!(Saturating(10isize).signum(), Saturating(1));
assert_eq!(Saturating(0isize).signum(), Saturating(0));
assert_eq!(Saturating(-10isize).signum(), Saturating(-1));

pub const fn is_positive(self) -> bool

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

如果 self 为正数，则返回 true; 如果数字为零或负数，则返回 false。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert!(Saturating(10isize).is_positive());
assert!(!Saturating(-10isize).is_positive());

pub const fn is_negative(self) -> bool

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

如果 self 为负，则返回 true; 如果数字为零或正，则返回 false。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert!(Saturating(-10isize).is_negative());
assert!(!Saturating(10isize).is_negative());

impl Saturating<i8>

pub const fn leading_zeros(self) -> u32

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

返回 self 二进制表示形式中前导零的数目。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n = Saturating(i8::MAX >> 2);

assert_eq!(n.leading_zeros(), 3);

pub fn abs(self) -> Saturating<i8>

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

饱和绝对值。 计算 self.abs()，如果 self == MIN 则返回 MAX 而不是溢出。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert_eq!(Saturating(100i8).abs(), Saturating(100));
assert_eq!(Saturating(-100i8).abs(), Saturating(100));
assert_eq!(Saturating(i8::MIN).abs(), Saturating((i8::MIN + 1).abs()));
assert_eq!(Saturating(i8::MIN).abs(), Saturating(i8::MIN.saturating_abs()));
assert_eq!(Saturating(i8::MIN).abs(), Saturating(i8::MAX));

pub fn signum(self) -> Saturating<i8>

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

返回一个表示 self 的符号的数字。

• 0 如果数字为零
• 1 如果数字是正数
• -1 如果数字是负数

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert_eq!(Saturating(10i8).signum(), Saturating(1));
assert_eq!(Saturating(0i8).signum(), Saturating(0));
assert_eq!(Saturating(-10i8).signum(), Saturating(-1));

pub const fn is_positive(self) -> bool

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

如果 self 为正数，则返回 true; 如果数字为零或负数，则返回 false。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert!(Saturating(10i8).is_positive());
assert!(!Saturating(-10i8).is_positive());

pub const fn is_negative(self) -> bool

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

如果 self 为负，则返回 true; 如果数字为零或正，则返回 false。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert!(Saturating(-10i8).is_negative());
assert!(!Saturating(10i8).is_negative());

impl Saturating<i16>

pub const fn leading_zeros(self) -> u32

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

返回 self 二进制表示形式中前导零的数目。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n = Saturating(i16::MAX >> 2);

assert_eq!(n.leading_zeros(), 3);

pub fn abs(self) -> Saturating<i16>

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

饱和绝对值。 计算 self.abs()，如果 self == MIN 则返回 MAX 而不是溢出。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert_eq!(Saturating(100i16).abs(), Saturating(100));
assert_eq!(Saturating(-100i16).abs(), Saturating(100));
assert_eq!(Saturating(i16::MIN).abs(), Saturating((i16::MIN + 1).abs()));
assert_eq!(Saturating(i16::MIN).abs(), Saturating(i16::MIN.saturating_abs()));
assert_eq!(Saturating(i16::MIN).abs(), Saturating(i16::MAX));

pub fn signum(self) -> Saturating<i16>

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

返回一个表示 self 的符号的数字。

• 0 如果数字为零
• 1 如果数字是正数
• -1 如果数字是负数

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert_eq!(Saturating(10i16).signum(), Saturating(1));
assert_eq!(Saturating(0i16).signum(), Saturating(0));
assert_eq!(Saturating(-10i16).signum(), Saturating(-1));

pub const fn is_positive(self) -> bool

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

如果 self 为正数，则返回 true; 如果数字为零或负数，则返回 false。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert!(Saturating(10i16).is_positive());
assert!(!Saturating(-10i16).is_positive());

pub const fn is_negative(self) -> bool

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

如果 self 为负，则返回 true; 如果数字为零或正，则返回 false。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert!(Saturating(-10i16).is_negative());
assert!(!Saturating(10i16).is_negative());

impl Saturating<i32>

pub const fn leading_zeros(self) -> u32

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

返回 self 二进制表示形式中前导零的数目。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n = Saturating(i32::MAX >> 2);

assert_eq!(n.leading_zeros(), 3);

pub fn abs(self) -> Saturating<i32>

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

饱和绝对值。 计算 self.abs()，如果 self == MIN 则返回 MAX 而不是溢出。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert_eq!(Saturating(100i32).abs(), Saturating(100));
assert_eq!(Saturating(-100i32).abs(), Saturating(100));
assert_eq!(Saturating(i32::MIN).abs(), Saturating((i32::MIN + 1).abs()));
assert_eq!(Saturating(i32::MIN).abs(), Saturating(i32::MIN.saturating_abs()));
assert_eq!(Saturating(i32::MIN).abs(), Saturating(i32::MAX));

pub fn signum(self) -> Saturating<i32>

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

返回一个表示 self 的符号的数字。

• 0 如果数字为零
• 1 如果数字是正数
• -1 如果数字是负数

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert_eq!(Saturating(10i32).signum(), Saturating(1));
assert_eq!(Saturating(0i32).signum(), Saturating(0));
assert_eq!(Saturating(-10i32).signum(), Saturating(-1));

pub const fn is_positive(self) -> bool

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

如果 self 为正数，则返回 true; 如果数字为零或负数，则返回 false。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert!(Saturating(10i32).is_positive());
assert!(!Saturating(-10i32).is_positive());

pub const fn is_negative(self) -> bool

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

如果 self 为负，则返回 true; 如果数字为零或正，则返回 false。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert!(Saturating(-10i32).is_negative());
assert!(!Saturating(10i32).is_negative());

impl Saturating<i64>

pub const fn leading_zeros(self) -> u32

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

返回 self 二进制表示形式中前导零的数目。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n = Saturating(i64::MAX >> 2);

assert_eq!(n.leading_zeros(), 3);

pub fn abs(self) -> Saturating<i64>

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

饱和绝对值。 计算 self.abs()，如果 self == MIN 则返回 MAX 而不是溢出。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert_eq!(Saturating(100i64).abs(), Saturating(100));
assert_eq!(Saturating(-100i64).abs(), Saturating(100));
assert_eq!(Saturating(i64::MIN).abs(), Saturating((i64::MIN + 1).abs()));
assert_eq!(Saturating(i64::MIN).abs(), Saturating(i64::MIN.saturating_abs()));
assert_eq!(Saturating(i64::MIN).abs(), Saturating(i64::MAX));

pub fn signum(self) -> Saturating<i64>

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

返回一个表示 self 的符号的数字。

• 0 如果数字为零
• 1 如果数字是正数
• -1 如果数字是负数

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert_eq!(Saturating(10i64).signum(), Saturating(1));
assert_eq!(Saturating(0i64).signum(), Saturating(0));
assert_eq!(Saturating(-10i64).signum(), Saturating(-1));

pub const fn is_positive(self) -> bool

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

如果 self 为正数，则返回 true; 如果数字为零或负数，则返回 false。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert!(Saturating(10i64).is_positive());
assert!(!Saturating(-10i64).is_positive());

pub const fn is_negative(self) -> bool

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

如果 self 为负，则返回 true; 如果数字为零或正，则返回 false。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert!(Saturating(-10i64).is_negative());
assert!(!Saturating(10i64).is_negative());

impl Saturating<i128>

pub const fn leading_zeros(self) -> u32

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

返回 self 二进制表示形式中前导零的数目。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n = Saturating(i128::MAX >> 2);

assert_eq!(n.leading_zeros(), 3);

pub fn abs(self) -> Saturating<i128>

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

饱和绝对值。 计算 self.abs()，如果 self == MIN 则返回 MAX 而不是溢出。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert_eq!(Saturating(100i128).abs(), Saturating(100));
assert_eq!(Saturating(-100i128).abs(), Saturating(100));
assert_eq!(Saturating(i128::MIN).abs(), Saturating((i128::MIN + 1).abs()));
assert_eq!(Saturating(i128::MIN).abs(), Saturating(i128::MIN.saturating_abs()));
assert_eq!(Saturating(i128::MIN).abs(), Saturating(i128::MAX));

pub fn signum(self) -> Saturating<i128>

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

返回一个表示 self 的符号的数字。

• 0 如果数字为零
• 1 如果数字是正数
• -1 如果数字是负数

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert_eq!(Saturating(10i128).signum(), Saturating(1));
assert_eq!(Saturating(0i128).signum(), Saturating(0));
assert_eq!(Saturating(-10i128).signum(), Saturating(-1));

pub const fn is_positive(self) -> bool

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

如果 self 为正数，则返回 true; 如果数字为零或负数，则返回 false。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert!(Saturating(10i128).is_positive());
assert!(!Saturating(-10i128).is_positive());

pub const fn is_negative(self) -> bool

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

如果 self 为负，则返回 true; 如果数字为零或正，则返回 false。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert!(Saturating(-10i128).is_negative());
assert!(!Saturating(10i128).is_negative());

impl Saturating<usize>

pub const fn leading_zeros(self) -> u32

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

返回 self 二进制表示形式中前导零的数目。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n = Saturating(usize::MAX >> 2);

assert_eq!(n.leading_zeros(), 2);

pub fn is_power_of_two(self) -> bool

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

当且仅当某些 k 的 self == 2^k 时，才返回 true。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert!(Saturating(16usize).is_power_of_two());
assert!(!Saturating(10usize).is_power_of_two());

impl Saturating<u8>

pub const fn leading_zeros(self) -> u32

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

返回 self 二进制表示形式中前导零的数目。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n = Saturating(u8::MAX >> 2);

assert_eq!(n.leading_zeros(), 2);

pub fn is_power_of_two(self) -> bool

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

当且仅当某些 k 的 self == 2^k 时，才返回 true。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert!(Saturating(16u8).is_power_of_two());
assert!(!Saturating(10u8).is_power_of_two());

impl Saturating<u16>

pub const fn leading_zeros(self) -> u32

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

返回 self 二进制表示形式中前导零的数目。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n = Saturating(u16::MAX >> 2);

assert_eq!(n.leading_zeros(), 2);

pub fn is_power_of_two(self) -> bool

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

当且仅当某些 k 的 self == 2^k 时，才返回 true。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert!(Saturating(16u16).is_power_of_two());
assert!(!Saturating(10u16).is_power_of_two());

impl Saturating<u32>

pub const fn leading_zeros(self) -> u32

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

返回 self 二进制表示形式中前导零的数目。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n = Saturating(u32::MAX >> 2);

assert_eq!(n.leading_zeros(), 2);

pub fn is_power_of_two(self) -> bool

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

当且仅当某些 k 的 self == 2^k 时，才返回 true。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert!(Saturating(16u32).is_power_of_two());
assert!(!Saturating(10u32).is_power_of_two());

impl Saturating<u64>

pub const fn leading_zeros(self) -> u32

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

返回 self 二进制表示形式中前导零的数目。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n = Saturating(u64::MAX >> 2);

assert_eq!(n.leading_zeros(), 2);

pub fn is_power_of_two(self) -> bool

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

当且仅当某些 k 的 self == 2^k 时，才返回 true。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert!(Saturating(16u64).is_power_of_two());
assert!(!Saturating(10u64).is_power_of_two());

impl Saturating<u128>

pub const fn leading_zeros(self) -> u32

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

返回 self 二进制表示形式中前导零的数目。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

let n = Saturating(u128::MAX >> 2);

assert_eq!(n.leading_zeros(), 2);

pub fn is_power_of_two(self) -> bool

🔬 This is a nightly-only experimental API. (saturating_int_impl #87920)

当且仅当某些 k 的 self == 2^k 时，才返回 true。

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert!(Saturating(16u128).is_power_of_two());
assert!(!Saturating(10u128).is_power_of_two());

Trait Implementations

impl Add<&'_ Saturating<i128>> for Saturating<i128>

type Output = <Saturating<i128> as Add<Saturating<i128>>>::Output

应用 + 运算符后的结果类型。

fn add(
    self,
    other: &Saturating<i128>
) -> <Saturating<i128> as Add<Saturating<i128>>>::Output

执行 + 操作。

impl Add<&'_ Saturating<i128>> for &Saturating<i128>

type Output = <Saturating<i128> as Add<Saturating<i128>>>::Output

应用 + 运算符后的结果类型。

fn add(
    self,
    other: &Saturating<i128>
) -> <Saturating<i128> as Add<Saturating<i128>>>::Output

执行 + 操作。

impl Add<&'_ Saturating<i16>> for Saturating<i16>

type Output = <Saturating<i16> as Add<Saturating<i16>>>::Output

应用 + 运算符后的结果类型。

fn add(
    self,
    other: &Saturating<i16>
) -> <Saturating<i16> as Add<Saturating<i16>>>::Output

执行 + 操作。

impl Add<&'_ Saturating<i16>> for &Saturating<i16>

type Output = <Saturating<i16> as Add<Saturating<i16>>>::Output

应用 + 运算符后的结果类型。

fn add(
    self,
    other: &Saturating<i16>
) -> <Saturating<i16> as Add<Saturating<i16>>>::Output

执行 + 操作。

impl Add<&'_ Saturating<i32>> for Saturating<i32>

type Output = <Saturating<i32> as Add<Saturating<i32>>>::Output

应用 + 运算符后的结果类型。

fn add(
    self,
    other: &Saturating<i32>
) -> <Saturating<i32> as Add<Saturating<i32>>>::Output

执行 + 操作。

impl Add<&'_ Saturating<i32>> for &Saturating<i32>

type Output = <Saturating<i32> as Add<Saturating<i32>>>::Output

应用 + 运算符后的结果类型。

fn add(
    self,
    other: &Saturating<i32>
) -> <Saturating<i32> as Add<Saturating<i32>>>::Output

执行 + 操作。

impl Add<&'_ Saturating<i64>> for Saturating<i64>

type Output = <Saturating<i64> as Add<Saturating<i64>>>::Output

应用 + 运算符后的结果类型。

fn add(
    self,
    other: &Saturating<i64>
) -> <Saturating<i64> as Add<Saturating<i64>>>::Output

执行 + 操作。

impl Add<&'_ Saturating<i64>> for &Saturating<i64>

type Output = <Saturating<i64> as Add<Saturating<i64>>>::Output

应用 + 运算符后的结果类型。

fn add(
    self,
    other: &Saturating<i64>
) -> <Saturating<i64> as Add<Saturating<i64>>>::Output

执行 + 操作。

impl Add<&'_ Saturating<i8>> for Saturating<i8>

type Output = <Saturating<i8> as Add<Saturating<i8>>>::Output

应用 + 运算符后的结果类型。

fn add(
    self,
    other: &Saturating<i8>
) -> <Saturating<i8> as Add<Saturating<i8>>>::Output

执行 + 操作。

impl Add<&'_ Saturating<i8>> for &Saturating<i8>

type Output = <Saturating<i8> as Add<Saturating<i8>>>::Output

应用 + 运算符后的结果类型。

fn add(
    self,
    other: &Saturating<i8>
) -> <Saturating<i8> as Add<Saturating<i8>>>::Output

执行 + 操作。

impl Add<&'_ Saturating<isize>> for Saturating<isize>

type Output = <Saturating<isize> as Add<Saturating<isize>>>::Output

应用 + 运算符后的结果类型。

fn add(
    self,
    other: &Saturating<isize>
) -> <Saturating<isize> as Add<Saturating<isize>>>::Output

执行 + 操作。

impl Add<&'_ Saturating<isize>> for &Saturating<isize>

type Output = <Saturating<isize> as Add<Saturating<isize>>>::Output

应用 + 运算符后的结果类型。

fn add(
    self,
    other: &Saturating<isize>
) -> <Saturating<isize> as Add<Saturating<isize>>>::Output

执行 + 操作。

impl Add<&'_ Saturating<u128>> for Saturating<u128>

type Output = <Saturating<u128> as Add<Saturating<u128>>>::Output

应用 + 运算符后的结果类型。

fn add(
    self,
    other: &Saturating<u128>
) -> <Saturating<u128> as Add<Saturating<u128>>>::Output

执行 + 操作。

impl Add<&'_ Saturating<u128>> for &Saturating<u128>

type Output = <Saturating<u128> as Add<Saturating<u128>>>::Output

应用 + 运算符后的结果类型。

fn add(
    self,
    other: &Saturating<u128>
) -> <Saturating<u128> as Add<Saturating<u128>>>::Output

执行 + 操作。

impl Add<&'_ Saturating<u16>> for Saturating<u16>

type Output = <Saturating<u16> as Add<Saturating<u16>>>::Output

应用 + 运算符后的结果类型。

fn add(
    self,
    other: &Saturating<u16>
) -> <Saturating<u16> as Add<Saturating<u16>>>::Output

执行 + 操作。

impl Add<&'_ Saturating<u16>> for &Saturating<u16>

type Output = <Saturating<u16> as Add<Saturating<u16>>>::Output

应用 + 运算符后的结果类型。

fn add(
    self,
    other: &Saturating<u16>
) -> <Saturating<u16> as Add<Saturating<u16>>>::Output

执行 + 操作。

impl Add<&'_ Saturating<u32>> for Saturating<u32>

type Output = <Saturating<u32> as Add<Saturating<u32>>>::Output

应用 + 运算符后的结果类型。

fn add(
    self,
    other: &Saturating<u32>
) -> <Saturating<u32> as Add<Saturating<u32>>>::Output

执行 + 操作。

impl Add<&'_ Saturating<u32>> for &Saturating<u32>

type Output = <Saturating<u32> as Add<Saturating<u32>>>::Output

应用 + 运算符后的结果类型。

fn add(
    self,
    other: &Saturating<u32>
) -> <Saturating<u32> as Add<Saturating<u32>>>::Output

执行 + 操作。

impl Add<&'_ Saturating<u64>> for Saturating<u64>

type Output = <Saturating<u64> as Add<Saturating<u64>>>::Output

应用 + 运算符后的结果类型。

fn add(
    self,
    other: &Saturating<u64>
) -> <Saturating<u64> as Add<Saturating<u64>>>::Output

执行 + 操作。

impl Add<&'_ Saturating<u64>> for &Saturating<u64>

type Output = <Saturating<u64> as Add<Saturating<u64>>>::Output

应用 + 运算符后的结果类型。

fn add(
    self,
    other: &Saturating<u64>
) -> <Saturating<u64> as Add<Saturating<u64>>>::Output

执行 + 操作。

impl Add<&'_ Saturating<u8>> for Saturating<u8>

type Output = <Saturating<u8> as Add<Saturating<u8>>>::Output

应用 + 运算符后的结果类型。

fn add(
    self,
    other: &Saturating<u8>
) -> <Saturating<u8> as Add<Saturating<u8>>>::Output

执行 + 操作。

impl Add<&'_ Saturating<u8>> for &Saturating<u8>

type Output = <Saturating<u8> as Add<Saturating<u8>>>::Output

应用 + 运算符后的结果类型。

fn add(
    self,
    other: &Saturating<u8>
) -> <Saturating<u8> as Add<Saturating<u8>>>::Output

执行 + 操作。

impl Add<&'_ Saturating<usize>> for Saturating<usize>

type Output = <Saturating<usize> as Add<Saturating<usize>>>::Output

应用 + 运算符后的结果类型。

fn add(
    self,
    other: &Saturating<usize>
) -> <Saturating<usize> as Add<Saturating<usize>>>::Output

执行 + 操作。

impl Add<&'_ Saturating<usize>> for &Saturating<usize>

type Output = <Saturating<usize> as Add<Saturating<usize>>>::Output

应用 + 运算符后的结果类型。

fn add(
    self,
    other: &Saturating<usize>
) -> <Saturating<usize> as Add<Saturating<usize>>>::Output

执行 + 操作。

impl Add<Saturating<i128>> for Saturating<i128>

type Output = Saturating<i128>

应用 + 运算符后的结果类型。

fn add(self, other: Saturating<i128>) -> Saturating<i128>

执行 + 操作。

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

type Output = <Saturating<i128> as Add<Saturating<i128>>>::Output

应用 + 运算符后的结果类型。

fn add(
    self,
    other: Saturating<i128>
) -> <Saturating<i128> as Add<Saturating<i128>>>::Output

执行 + 操作。

impl Add<Saturating<i16>> for Saturating<i16>

type Output = Saturating<i16>

应用 + 运算符后的结果类型。

fn add(self, other: Saturating<i16>) -> Saturating<i16>

执行 + 操作。

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

type Output = <Saturating<i16> as Add<Saturating<i16>>>::Output

应用 + 运算符后的结果类型。

fn add(
    self,
    other: Saturating<i16>
) -> <Saturating<i16> as Add<Saturating<i16>>>::Output

执行 + 操作。

impl Add<Saturating<i32>> for Saturating<i32>

type Output = Saturating<i32>

应用 + 运算符后的结果类型。

fn add(self, other: Saturating<i32>) -> Saturating<i32>

执行 + 操作。

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

type Output = <Saturating<i32> as Add<Saturating<i32>>>::Output

应用 + 运算符后的结果类型。

fn add(
    self,
    other: Saturating<i32>
) -> <Saturating<i32> as Add<Saturating<i32>>>::Output

执行 + 操作。

impl Add<Saturating<i64>> for Saturating<i64>

type Output = Saturating<i64>

应用 + 运算符后的结果类型。

fn add(self, other: Saturating<i64>) -> Saturating<i64>

执行 + 操作。

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

type Output = <Saturating<i64> as Add<Saturating<i64>>>::Output

应用 + 运算符后的结果类型。

fn add(
    self,
    other: Saturating<i64>
) -> <Saturating<i64> as Add<Saturating<i64>>>::Output

执行 + 操作。

impl Add<Saturating<i8>> for Saturating<i8>

type Output = Saturating<i8>

应用 + 运算符后的结果类型。

fn add(self, other: Saturating<i8>) -> Saturating<i8>

执行 + 操作。

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

type Output = <Saturating<i8> as Add<Saturating<i8>>>::Output

应用 + 运算符后的结果类型。

fn add(
    self,
    other: Saturating<i8>
) -> <Saturating<i8> as Add<Saturating<i8>>>::Output

执行 + 操作。

impl Add<Saturating<isize>> for Saturating<isize>

type Output = Saturating<isize>

应用 + 运算符后的结果类型。

fn add(self, other: Saturating<isize>) -> Saturating<isize>

执行 + 操作。

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

type Output = <Saturating<isize> as Add<Saturating<isize>>>::Output

应用 + 运算符后的结果类型。

fn add(
    self,
    other: Saturating<isize>
) -> <Saturating<isize> as Add<Saturating<isize>>>::Output

执行 + 操作。

impl Add<Saturating<u128>> for Saturating<u128>

type Output = Saturating<u128>

应用 + 运算符后的结果类型。

fn add(self, other: Saturating<u128>) -> Saturating<u128>

执行 + 操作。

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

type Output = <Saturating<u128> as Add<Saturating<u128>>>::Output

应用 + 运算符后的结果类型。

fn add(
    self,
    other: Saturating<u128>
) -> <Saturating<u128> as Add<Saturating<u128>>>::Output

执行 + 操作。

impl Add<Saturating<u16>> for Saturating<u16>

type Output = Saturating<u16>

应用 + 运算符后的结果类型。

fn add(self, other: Saturating<u16>) -> Saturating<u16>

执行 + 操作。

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

type Output = <Saturating<u16> as Add<Saturating<u16>>>::Output

应用 + 运算符后的结果类型。

fn add(
    self,
    other: Saturating<u16>
) -> <Saturating<u16> as Add<Saturating<u16>>>::Output

执行 + 操作。

impl Add<Saturating<u32>> for Saturating<u32>

type Output = Saturating<u32>

应用 + 运算符后的结果类型。

fn add(self, other: Saturating<u32>) -> Saturating<u32>

执行 + 操作。

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

type Output = <Saturating<u32> as Add<Saturating<u32>>>::Output

应用 + 运算符后的结果类型。

fn add(
    self,
    other: Saturating<u32>
) -> <Saturating<u32> as Add<Saturating<u32>>>::Output

执行 + 操作。

impl Add<Saturating<u64>> for Saturating<u64>

type Output = Saturating<u64>

应用 + 运算符后的结果类型。

fn add(self, other: Saturating<u64>) -> Saturating<u64>

执行 + 操作。

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

type Output = <Saturating<u64> as Add<Saturating<u64>>>::Output

应用 + 运算符后的结果类型。

fn add(
    self,
    other: Saturating<u64>
) -> <Saturating<u64> as Add<Saturating<u64>>>::Output

执行 + 操作。

impl Add<Saturating<u8>> for Saturating<u8>

type Output = Saturating<u8>

应用 + 运算符后的结果类型。

fn add(self, other: Saturating<u8>) -> Saturating<u8>

执行 + 操作。

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

type Output = <Saturating<u8> as Add<Saturating<u8>>>::Output

应用 + 运算符后的结果类型。

fn add(
    self,
    other: Saturating<u8>
) -> <Saturating<u8> as Add<Saturating<u8>>>::Output

执行 + 操作。

impl Add<Saturating<usize>> for Saturating<usize>

type Output = Saturating<usize>

应用 + 运算符后的结果类型。

fn add(self, other: Saturating<usize>) -> Saturating<usize>

执行 + 操作。

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

type Output = <Saturating<usize> as Add<Saturating<usize>>>::Output

应用 + 运算符后的结果类型。

fn add(
    self,
    other: Saturating<usize>
) -> <Saturating<usize> as Add<Saturating<usize>>>::Output

执行 + 操作。

impl AddAssign<&'_ Saturating<i128>> for Saturating<i128>

fn add_assign(&mut self, other: &Saturating<i128>)

执行 += 操作。

impl AddAssign<&'_ Saturating<i16>> for Saturating<i16>

fn add_assign(&mut self, other: &Saturating<i16>)

执行 += 操作。

impl AddAssign<&'_ Saturating<i32>> for Saturating<i32>

fn add_assign(&mut self, other: &Saturating<i32>)

执行 += 操作。

impl AddAssign<&'_ Saturating<i64>> for Saturating<i64>

fn add_assign(&mut self, other: &Saturating<i64>)

执行 += 操作。

impl AddAssign<&'_ Saturating<i8>> for Saturating<i8>

fn add_assign(&mut self, other: &Saturating<i8>)

执行 += 操作。

impl AddAssign<&'_ Saturating<isize>> for Saturating<isize>

fn add_assign(&mut self, other: &Saturating<isize>)

执行 += 操作。

impl AddAssign<&'_ Saturating<u128>> for Saturating<u128>

fn add_assign(&mut self, other: &Saturating<u128>)

执行 += 操作。

impl AddAssign<&'_ Saturating<u16>> for Saturating<u16>

fn add_assign(&mut self, other: &Saturating<u16>)

执行 += 操作。

impl AddAssign<&'_ Saturating<u32>> for Saturating<u32>

fn add_assign(&mut self, other: &Saturating<u32>)

执行 += 操作。

impl AddAssign<&'_ Saturating<u64>> for Saturating<u64>

fn add_assign(&mut self, other: &Saturating<u64>)

执行 += 操作。

impl AddAssign<&'_ Saturating<u8>> for Saturating<u8>

fn add_assign(&mut self, other: &Saturating<u8>)

执行 += 操作。

impl AddAssign<&'_ Saturating<usize>> for Saturating<usize>

fn add_assign(&mut self, other: &Saturating<usize>)

执行 += 操作。

impl AddAssign<Saturating<i128>> for Saturating<i128>

fn add_assign(&mut self, other: Saturating<i128>)

执行 += 操作。

impl AddAssign<Saturating<i16>> for Saturating<i16>

fn add_assign(&mut self, other: Saturating<i16>)

执行 += 操作。

impl AddAssign<Saturating<i32>> for Saturating<i32>

fn add_assign(&mut self, other: Saturating<i32>)

执行 += 操作。

impl AddAssign<Saturating<i64>> for Saturating<i64>

fn add_assign(&mut self, other: Saturating<i64>)

执行 += 操作。

impl AddAssign<Saturating<i8>> for Saturating<i8>

fn add_assign(&mut self, other: Saturating<i8>)

执行 += 操作。

impl AddAssign<Saturating<isize>> for Saturating<isize>

fn add_assign(&mut self, other: Saturating<isize>)

执行 += 操作。

impl AddAssign<Saturating<u128>> for Saturating<u128>

fn add_assign(&mut self, other: Saturating<u128>)

执行 += 操作。

impl AddAssign<Saturating<u16>> for Saturating<u16>

fn add_assign(&mut self, other: Saturating<u16>)

执行 += 操作。

impl AddAssign<Saturating<u32>> for Saturating<u32>

fn add_assign(&mut self, other: Saturating<u32>)

执行 += 操作。

impl AddAssign<Saturating<u64>> for Saturating<u64>

fn add_assign(&mut self, other: Saturating<u64>)

执行 += 操作。

impl AddAssign<Saturating<u8>> for Saturating<u8>

fn add_assign(&mut self, other: Saturating<u8>)

执行 += 操作。

impl AddAssign<Saturating<usize>> for Saturating<usize>

fn add_assign(&mut self, other: Saturating<usize>)

执行 += 操作。

impl<T: Binary> Binary for Saturating<T>

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

使用给定的格式化程序格式化该值。

impl BitAnd<&'_ Saturating<i128>> for Saturating<i128>

type Output = <Saturating<i128> as BitAnd<Saturating<i128>>>::Output

应用 & 运算符后的结果类型。

fn bitand(
    self,
    other: &Saturating<i128>
) -> <Saturating<i128> as BitAnd<Saturating<i128>>>::Output

执行 & 操作。

impl BitAnd<&'_ Saturating<i128>> for &Saturating<i128>

type Output = <Saturating<i128> as BitAnd<Saturating<i128>>>::Output

应用 & 运算符后的结果类型。

fn bitand(
    self,
    other: &Saturating<i128>
) -> <Saturating<i128> as BitAnd<Saturating<i128>>>::Output

执行 & 操作。

impl BitAnd<&'_ Saturating<i16>> for Saturating<i16>

type Output = <Saturating<i16> as BitAnd<Saturating<i16>>>::Output

应用 & 运算符后的结果类型。

fn bitand(
    self,
    other: &Saturating<i16>
) -> <Saturating<i16> as BitAnd<Saturating<i16>>>::Output

执行 & 操作。

impl BitAnd<&'_ Saturating<i16>> for &Saturating<i16>

type Output = <Saturating<i16> as BitAnd<Saturating<i16>>>::Output

应用 & 运算符后的结果类型。

fn bitand(
    self,
    other: &Saturating<i16>
) -> <Saturating<i16> as BitAnd<Saturating<i16>>>::Output

执行 & 操作。

impl BitAnd<&'_ Saturating<i32>> for Saturating<i32>

type Output = <Saturating<i32> as BitAnd<Saturating<i32>>>::Output

应用 & 运算符后的结果类型。

fn bitand(
    self,
    other: &Saturating<i32>
) -> <Saturating<i32> as BitAnd<Saturating<i32>>>::Output

执行 & 操作。

impl BitAnd<&'_ Saturating<i32>> for &Saturating<i32>

type Output = <Saturating<i32> as BitAnd<Saturating<i32>>>::Output

应用 & 运算符后的结果类型。

fn bitand(
    self,
    other: &Saturating<i32>
) -> <Saturating<i32> as BitAnd<Saturating<i32>>>::Output

执行 & 操作。

impl BitAnd<&'_ Saturating<i64>> for Saturating<i64>

type Output = <Saturating<i64> as BitAnd<Saturating<i64>>>::Output

应用 & 运算符后的结果类型。

fn bitand(
    self,
    other: &Saturating<i64>
) -> <Saturating<i64> as BitAnd<Saturating<i64>>>::Output

执行 & 操作。

impl BitAnd<&'_ Saturating<i64>> for &Saturating<i64>

type Output = <Saturating<i64> as BitAnd<Saturating<i64>>>::Output

应用 & 运算符后的结果类型。

fn bitand(
    self,
    other: &Saturating<i64>
) -> <Saturating<i64> as BitAnd<Saturating<i64>>>::Output

执行 & 操作。

impl BitAnd<&'_ Saturating<i8>> for Saturating<i8>

type Output = <Saturating<i8> as BitAnd<Saturating<i8>>>::Output

应用 & 运算符后的结果类型。

fn bitand(
    self,
    other: &Saturating<i8>
) -> <Saturating<i8> as BitAnd<Saturating<i8>>>::Output

执行 & 操作。

impl BitAnd<&'_ Saturating<i8>> for &Saturating<i8>

type Output = <Saturating<i8> as BitAnd<Saturating<i8>>>::Output

应用 & 运算符后的结果类型。

fn bitand(
    self,
    other: &Saturating<i8>
) -> <Saturating<i8> as BitAnd<Saturating<i8>>>::Output

执行 & 操作。

impl BitAnd<&'_ Saturating<isize>> for Saturating<isize>

type Output = <Saturating<isize> as BitAnd<Saturating<isize>>>::Output

应用 & 运算符后的结果类型。

fn bitand(
    self,
    other: &Saturating<isize>
) -> <Saturating<isize> as BitAnd<Saturating<isize>>>::Output

执行 & 操作。

impl BitAnd<&'_ Saturating<isize>> for &Saturating<isize>

type Output = <Saturating<isize> as BitAnd<Saturating<isize>>>::Output

应用 & 运算符后的结果类型。

fn bitand(
    self,
    other: &Saturating<isize>
) -> <Saturating<isize> as BitAnd<Saturating<isize>>>::Output

执行 & 操作。

impl BitAnd<&'_ Saturating<u128>> for Saturating<u128>

type Output = <Saturating<u128> as BitAnd<Saturating<u128>>>::Output

应用 & 运算符后的结果类型。

fn bitand(
    self,
    other: &Saturating<u128>
) -> <Saturating<u128> as BitAnd<Saturating<u128>>>::Output

执行 & 操作。

impl BitAnd<&'_ Saturating<u128>> for &Saturating<u128>

type Output = <Saturating<u128> as BitAnd<Saturating<u128>>>::Output

应用 & 运算符后的结果类型。

fn bitand(
    self,
    other: &Saturating<u128>
) -> <Saturating<u128> as BitAnd<Saturating<u128>>>::Output

执行 & 操作。

impl BitAnd<&'_ Saturating<u16>> for Saturating<u16>

type Output = <Saturating<u16> as BitAnd<Saturating<u16>>>::Output

应用 & 运算符后的结果类型。

fn bitand(
    self,
    other: &Saturating<u16>
) -> <Saturating<u16> as BitAnd<Saturating<u16>>>::Output

执行 & 操作。

impl BitAnd<&'_ Saturating<u16>> for &Saturating<u16>

type Output = <Saturating<u16> as BitAnd<Saturating<u16>>>::Output

应用 & 运算符后的结果类型。

fn bitand(
    self,
    other: &Saturating<u16>
) -> <Saturating<u16> as BitAnd<Saturating<u16>>>::Output

执行 & 操作。

impl BitAnd<&'_ Saturating<u32>> for Saturating<u32>

type Output = <Saturating<u32> as BitAnd<Saturating<u32>>>::Output

应用 & 运算符后的结果类型。

fn bitand(
    self,
    other: &Saturating<u32>
) -> <Saturating<u32> as BitAnd<Saturating<u32>>>::Output

执行 & 操作。

impl BitAnd<&'_ Saturating<u32>> for &Saturating<u32>

type Output = <Saturating<u32> as BitAnd<Saturating<u32>>>::Output

应用 & 运算符后的结果类型。

fn bitand(
    self,
    other: &Saturating<u32>
) -> <Saturating<u32> as BitAnd<Saturating<u32>>>::Output

执行 & 操作。

impl BitAnd<&'_ Saturating<u64>> for Saturating<u64>

type Output = <Saturating<u64> as BitAnd<Saturating<u64>>>::Output

应用 & 运算符后的结果类型。

fn bitand(
    self,
    other: &Saturating<u64>
) -> <Saturating<u64> as BitAnd<Saturating<u64>>>::Output

执行 & 操作。

impl BitAnd<&'_ Saturating<u64>> for &Saturating<u64>

type Output = <Saturating<u64> as BitAnd<Saturating<u64>>>::Output

应用 & 运算符后的结果类型。

fn bitand(
    self,
    other: &Saturating<u64>
) -> <Saturating<u64> as BitAnd<Saturating<u64>>>::Output

执行 & 操作。

impl BitAnd<&'_ Saturating<u8>> for Saturating<u8>

type Output = <Saturating<u8> as BitAnd<Saturating<u8>>>::Output

应用 & 运算符后的结果类型。

fn bitand(
    self,
    other: &Saturating<u8>
) -> <Saturating<u8> as BitAnd<Saturating<u8>>>::Output

执行 & 操作。

impl BitAnd<&'_ Saturating<u8>> for &Saturating<u8>

type Output = <Saturating<u8> as BitAnd<Saturating<u8>>>::Output

应用 & 运算符后的结果类型。

fn bitand(
    self,
    other: &Saturating<u8>
) -> <Saturating<u8> as BitAnd<Saturating<u8>>>::Output

执行 & 操作。

impl BitAnd<&'_ Saturating<usize>> for Saturating<usize>

type Output = <Saturating<usize> as BitAnd<Saturating<usize>>>::Output

应用 & 运算符后的结果类型。

fn bitand(
    self,
    other: &Saturating<usize>
) -> <Saturating<usize> as BitAnd<Saturating<usize>>>::Output

执行 & 操作。

impl BitAnd<&'_ Saturating<usize>> for &Saturating<usize>

type Output = <Saturating<usize> as BitAnd<Saturating<usize>>>::Output

应用 & 运算符后的结果类型。

fn bitand(
    self,
    other: &Saturating<usize>
) -> <Saturating<usize> as BitAnd<Saturating<usize>>>::Output

执行 & 操作。

impl BitAnd<Saturating<i128>> for Saturating<i128>

type Output = Saturating<i128>

应用 & 运算符后的结果类型。

fn bitand(self, other: Saturating<i128>) -> Saturating<i128>

执行 & 操作。

impl<'a> BitAnd<Saturating<i128>> for &'a Saturating<i128>

type Output = <Saturating<i128> as BitAnd<Saturating<i128>>>::Output

应用 & 运算符后的结果类型。

fn bitand(
    self,
    other: Saturating<i128>
) -> <Saturating<i128> as BitAnd<Saturating<i128>>>::Output

执行 & 操作。

impl BitAnd<Saturating<i16>> for Saturating<i16>

type Output = Saturating<i16>

应用 & 运算符后的结果类型。

fn bitand(self, other: Saturating<i16>) -> Saturating<i16>

执行 & 操作。

impl<'a> BitAnd<Saturating<i16>> for &'a Saturating<i16>

type Output = <Saturating<i16> as BitAnd<Saturating<i16>>>::Output

应用 & 运算符后的结果类型。

fn bitand(
    self,
    other: Saturating<i16>
) -> <Saturating<i16> as BitAnd<Saturating<i16>>>::Output

执行 & 操作。

impl BitAnd<Saturating<i32>> for Saturating<i32>

type Output = Saturating<i32>

应用 & 运算符后的结果类型。

fn bitand(self, other: Saturating<i32>) -> Saturating<i32>

执行 & 操作。

impl<'a> BitAnd<Saturating<i32>> for &'a Saturating<i32>

type Output = <Saturating<i32> as BitAnd<Saturating<i32>>>::Output

应用 & 运算符后的结果类型。

fn bitand(
    self,
    other: Saturating<i32>
) -> <Saturating<i32> as BitAnd<Saturating<i32>>>::Output

执行 & 操作。

impl BitAnd<Saturating<i64>> for Saturating<i64>

type Output = Saturating<i64>

应用 & 运算符后的结果类型。

fn bitand(self, other: Saturating<i64>) -> Saturating<i64>

执行 & 操作。

impl<'a> BitAnd<Saturating<i64>> for &'a Saturating<i64>

type Output = <Saturating<i64> as BitAnd<Saturating<i64>>>::Output

应用 & 运算符后的结果类型。

fn bitand(
    self,
    other: Saturating<i64>
) -> <Saturating<i64> as BitAnd<Saturating<i64>>>::Output

执行 & 操作。

impl BitAnd<Saturating<i8>> for Saturating<i8>

type Output = Saturating<i8>

应用 & 运算符后的结果类型。

fn bitand(self, other: Saturating<i8>) -> Saturating<i8>

执行 & 操作。

impl<'a> BitAnd<Saturating<i8>> for &'a Saturating<i8>

type Output = <Saturating<i8> as BitAnd<Saturating<i8>>>::Output

应用 & 运算符后的结果类型。

fn bitand(
    self,
    other: Saturating<i8>
) -> <Saturating<i8> as BitAnd<Saturating<i8>>>::Output

执行 & 操作。

impl BitAnd<Saturating<isize>> for Saturating<isize>

type Output = Saturating<isize>

应用 & 运算符后的结果类型。

fn bitand(self, other: Saturating<isize>) -> Saturating<isize>

执行 & 操作。

impl<'a> BitAnd<Saturating<isize>> for &'a Saturating<isize>

type Output = <Saturating<isize> as BitAnd<Saturating<isize>>>::Output

应用 & 运算符后的结果类型。

fn bitand(
    self,
    other: Saturating<isize>
) -> <Saturating<isize> as BitAnd<Saturating<isize>>>::Output

执行 & 操作。

impl BitAnd<Saturating<u128>> for Saturating<u128>

type Output = Saturating<u128>

应用 & 运算符后的结果类型。

fn bitand(self, other: Saturating<u128>) -> Saturating<u128>

执行 & 操作。

impl<'a> BitAnd<Saturating<u128>> for &'a Saturating<u128>

type Output = <Saturating<u128> as BitAnd<Saturating<u128>>>::Output

应用 & 运算符后的结果类型。

fn bitand(
    self,
    other: Saturating<u128>
) -> <Saturating<u128> as BitAnd<Saturating<u128>>>::Output

执行 & 操作。

impl BitAnd<Saturating<u16>> for Saturating<u16>

type Output = Saturating<u16>

应用 & 运算符后的结果类型。

fn bitand(self, other: Saturating<u16>) -> Saturating<u16>

执行 & 操作。

impl<'a> BitAnd<Saturating<u16>> for &'a Saturating<u16>

type Output = <Saturating<u16> as BitAnd<Saturating<u16>>>::Output

应用 & 运算符后的结果类型。

fn bitand(
    self,
    other: Saturating<u16>
) -> <Saturating<u16> as BitAnd<Saturating<u16>>>::Output

执行 & 操作。

impl BitAnd<Saturating<u32>> for Saturating<u32>

type Output = Saturating<u32>

应用 & 运算符后的结果类型。

fn bitand(self, other: Saturating<u32>) -> Saturating<u32>

执行 & 操作。

impl<'a> BitAnd<Saturating<u32>> for &'a Saturating<u32>

type Output = <Saturating<u32> as BitAnd<Saturating<u32>>>::Output

应用 & 运算符后的结果类型。

fn bitand(
    self,
    other: Saturating<u32>
) -> <Saturating<u32> as BitAnd<Saturating<u32>>>::Output

执行 & 操作。

impl BitAnd<Saturating<u64>> for Saturating<u64>

type Output = Saturating<u64>

应用 & 运算符后的结果类型。

fn bitand(self, other: Saturating<u64>) -> Saturating<u64>

执行 & 操作。

impl<'a> BitAnd<Saturating<u64>> for &'a Saturating<u64>

type Output = <Saturating<u64> as BitAnd<Saturating<u64>>>::Output

应用 & 运算符后的结果类型。

fn bitand(
    self,
    other: Saturating<u64>
) -> <Saturating<u64> as BitAnd<Saturating<u64>>>::Output

执行 & 操作。

impl BitAnd<Saturating<u8>> for Saturating<u8>

type Output = Saturating<u8>

应用 & 运算符后的结果类型。

fn bitand(self, other: Saturating<u8>) -> Saturating<u8>

执行 & 操作。

impl<'a> BitAnd<Saturating<u8>> for &'a Saturating<u8>

type Output = <Saturating<u8> as BitAnd<Saturating<u8>>>::Output

应用 & 运算符后的结果类型。

fn bitand(
    self,
    other: Saturating<u8>
) -> <Saturating<u8> as BitAnd<Saturating<u8>>>::Output

执行 & 操作。

impl BitAnd<Saturating<usize>> for Saturating<usize>

type Output = Saturating<usize>

应用 & 运算符后的结果类型。

fn bitand(self, other: Saturating<usize>) -> Saturating<usize>

执行 & 操作。

impl<'a> BitAnd<Saturating<usize>> for &'a Saturating<usize>

type Output = <Saturating<usize> as BitAnd<Saturating<usize>>>::Output

应用 & 运算符后的结果类型。

fn bitand(
    self,
    other: Saturating<usize>
) -> <Saturating<usize> as BitAnd<Saturating<usize>>>::Output

执行 & 操作。

impl BitAndAssign<&'_ Saturating<i128>> for Saturating<i128>

fn bitand_assign(&mut self, other: &Saturating<i128>)

执行 &= 操作。

impl BitAndAssign<&'_ Saturating<i16>> for Saturating<i16>

fn bitand_assign(&mut self, other: &Saturating<i16>)

执行 &= 操作。

impl BitAndAssign<&'_ Saturating<i32>> for Saturating<i32>

fn bitand_assign(&mut self, other: &Saturating<i32>)

执行 &= 操作。

impl BitAndAssign<&'_ Saturating<i64>> for Saturating<i64>

fn bitand_assign(&mut self, other: &Saturating<i64>)

执行 &= 操作。

impl BitAndAssign<&'_ Saturating<i8>> for Saturating<i8>

fn bitand_assign(&mut self, other: &Saturating<i8>)

执行 &= 操作。

impl BitAndAssign<&'_ Saturating<isize>> for Saturating<isize>

fn bitand_assign(&mut self, other: &Saturating<isize>)

执行 &= 操作。

impl BitAndAssign<&'_ Saturating<u128>> for Saturating<u128>

fn bitand_assign(&mut self, other: &Saturating<u128>)

执行 &= 操作。

impl BitAndAssign<&'_ Saturating<u16>> for Saturating<u16>

fn bitand_assign(&mut self, other: &Saturating<u16>)

执行 &= 操作。

impl BitAndAssign<&'_ Saturating<u32>> for Saturating<u32>

fn bitand_assign(&mut self, other: &Saturating<u32>)

执行 &= 操作。

impl BitAndAssign<&'_ Saturating<u64>> for Saturating<u64>

fn bitand_assign(&mut self, other: &Saturating<u64>)

执行 &= 操作。

impl BitAndAssign<&'_ Saturating<u8>> for Saturating<u8>

fn bitand_assign(&mut self, other: &Saturating<u8>)

执行 &= 操作。

impl BitAndAssign<&'_ Saturating<usize>> for Saturating<usize>

fn bitand_assign(&mut self, other: &Saturating<usize>)

执行 &= 操作。

impl BitAndAssign<Saturating<i128>> for Saturating<i128>

fn bitand_assign(&mut self, other: Saturating<i128>)

执行 &= 操作。

impl BitAndAssign<Saturating<i16>> for Saturating<i16>

fn bitand_assign(&mut self, other: Saturating<i16>)

执行 &= 操作。

impl BitAndAssign<Saturating<i32>> for Saturating<i32>

fn bitand_assign(&mut self, other: Saturating<i32>)

执行 &= 操作。

impl BitAndAssign<Saturating<i64>> for Saturating<i64>

fn bitand_assign(&mut self, other: Saturating<i64>)

执行 &= 操作。

impl BitAndAssign<Saturating<i8>> for Saturating<i8>

fn bitand_assign(&mut self, other: Saturating<i8>)

执行 &= 操作。

impl BitAndAssign<Saturating<isize>> for Saturating<isize>

fn bitand_assign(&mut self, other: Saturating<isize>)

执行 &= 操作。

impl BitAndAssign<Saturating<u128>> for Saturating<u128>

fn bitand_assign(&mut self, other: Saturating<u128>)

执行 &= 操作。

impl BitAndAssign<Saturating<u16>> for Saturating<u16>

fn bitand_assign(&mut self, other: Saturating<u16>)

执行 &= 操作。

impl BitAndAssign<Saturating<u32>> for Saturating<u32>

fn bitand_assign(&mut self, other: Saturating<u32>)

执行 &= 操作。

impl BitAndAssign<Saturating<u64>> for Saturating<u64>

fn bitand_assign(&mut self, other: Saturating<u64>)

执行 &= 操作。

impl BitAndAssign<Saturating<u8>> for Saturating<u8>

fn bitand_assign(&mut self, other: Saturating<u8>)

执行 &= 操作。

impl BitAndAssign<Saturating<usize>> for Saturating<usize>

fn bitand_assign(&mut self, other: Saturating<usize>)

执行 &= 操作。

impl BitOr<&'_ Saturating<i128>> for Saturating<i128>

type Output = <Saturating<i128> as BitOr<Saturating<i128>>>::Output

应用 | 运算符后的结果类型。

fn bitor(
    self,
    other: &Saturating<i128>
) -> <Saturating<i128> as BitOr<Saturating<i128>>>::Output

执行 | 操作。

impl BitOr<&'_ Saturating<i128>> for &Saturating<i128>

type Output = <Saturating<i128> as BitOr<Saturating<i128>>>::Output

应用 | 运算符后的结果类型。

fn bitor(
    self,
    other: &Saturating<i128>
) -> <Saturating<i128> as BitOr<Saturating<i128>>>::Output

执行 | 操作。

impl BitOr<&'_ Saturating<i16>> for Saturating<i16>

type Output = <Saturating<i16> as BitOr<Saturating<i16>>>::Output

应用 | 运算符后的结果类型。

fn bitor(
    self,
    other: &Saturating<i16>
) -> <Saturating<i16> as BitOr<Saturating<i16>>>::Output

执行 | 操作。

impl BitOr<&'_ Saturating<i16>> for &Saturating<i16>

type Output = <Saturating<i16> as BitOr<Saturating<i16>>>::Output

应用 | 运算符后的结果类型。

fn bitor(
    self,
    other: &Saturating<i16>
) -> <Saturating<i16> as BitOr<Saturating<i16>>>::Output

执行 | 操作。

impl BitOr<&'_ Saturating<i32>> for Saturating<i32>

type Output = <Saturating<i32> as BitOr<Saturating<i32>>>::Output

应用 | 运算符后的结果类型。

fn bitor(
    self,
    other: &Saturating<i32>
) -> <Saturating<i32> as BitOr<Saturating<i32>>>::Output

执行 | 操作。

impl BitOr<&'_ Saturating<i32>> for &Saturating<i32>

type Output = <Saturating<i32> as BitOr<Saturating<i32>>>::Output

应用 | 运算符后的结果类型。

fn bitor(
    self,
    other: &Saturating<i32>
) -> <Saturating<i32> as BitOr<Saturating<i32>>>::Output

执行 | 操作。

impl BitOr<&'_ Saturating<i64>> for Saturating<i64>

type Output = <Saturating<i64> as BitOr<Saturating<i64>>>::Output

应用 | 运算符后的结果类型。

fn bitor(
    self,
    other: &Saturating<i64>
) -> <Saturating<i64> as BitOr<Saturating<i64>>>::Output

执行 | 操作。

impl BitOr<&'_ Saturating<i64>> for &Saturating<i64>

type Output = <Saturating<i64> as BitOr<Saturating<i64>>>::Output

应用 | 运算符后的结果类型。

fn bitor(
    self,
    other: &Saturating<i64>
) -> <Saturating<i64> as BitOr<Saturating<i64>>>::Output

执行 | 操作。

impl BitOr<&'_ Saturating<i8>> for Saturating<i8>

type Output = <Saturating<i8> as BitOr<Saturating<i8>>>::Output

应用 | 运算符后的结果类型。

fn bitor(
    self,
    other: &Saturating<i8>
) -> <Saturating<i8> as BitOr<Saturating<i8>>>::Output

执行 | 操作。

impl BitOr<&'_ Saturating<i8>> for &Saturating<i8>

type Output = <Saturating<i8> as BitOr<Saturating<i8>>>::Output

应用 | 运算符后的结果类型。

fn bitor(
    self,
    other: &Saturating<i8>
) -> <Saturating<i8> as BitOr<Saturating<i8>>>::Output

执行 | 操作。

impl BitOr<&'_ Saturating<isize>> for Saturating<isize>

type Output = <Saturating<isize> as BitOr<Saturating<isize>>>::Output

应用 | 运算符后的结果类型。

fn bitor(
    self,
    other: &Saturating<isize>
) -> <Saturating<isize> as BitOr<Saturating<isize>>>::Output

执行 | 操作。

impl BitOr<&'_ Saturating<isize>> for &Saturating<isize>

type Output = <Saturating<isize> as BitOr<Saturating<isize>>>::Output

应用 | 运算符后的结果类型。

fn bitor(
    self,
    other: &Saturating<isize>
) -> <Saturating<isize> as BitOr<Saturating<isize>>>::Output

执行 | 操作。

impl BitOr<&'_ Saturating<u128>> for Saturating<u128>

type Output = <Saturating<u128> as BitOr<Saturating<u128>>>::Output

应用 | 运算符后的结果类型。

fn bitor(
    self,
    other: &Saturating<u128>
) -> <Saturating<u128> as BitOr<Saturating<u128>>>::Output

执行 | 操作。

impl BitOr<&'_ Saturating<u128>> for &Saturating<u128>

type Output = <Saturating<u128> as BitOr<Saturating<u128>>>::Output

应用 | 运算符后的结果类型。

fn bitor(
    self,
    other: &Saturating<u128>
) -> <Saturating<u128> as BitOr<Saturating<u128>>>::Output

执行 | 操作。

impl BitOr<&'_ Saturating<u16>> for Saturating<u16>

type Output = <Saturating<u16> as BitOr<Saturating<u16>>>::Output

应用 | 运算符后的结果类型。

fn bitor(
    self,
    other: &Saturating<u16>
) -> <Saturating<u16> as BitOr<Saturating<u16>>>::Output

执行 | 操作。

impl BitOr<&'_ Saturating<u16>> for &Saturating<u16>

type Output = <Saturating<u16> as BitOr<Saturating<u16>>>::Output

应用 | 运算符后的结果类型。

fn bitor(
    self,
    other: &Saturating<u16>
) -> <Saturating<u16> as BitOr<Saturating<u16>>>::Output

执行 | 操作。

impl BitOr<&'_ Saturating<u32>> for Saturating<u32>

type Output = <Saturating<u32> as BitOr<Saturating<u32>>>::Output

应用 | 运算符后的结果类型。

fn bitor(
    self,
    other: &Saturating<u32>
) -> <Saturating<u32> as BitOr<Saturating<u32>>>::Output

执行 | 操作。

impl BitOr<&'_ Saturating<u32>> for &Saturating<u32>

type Output = <Saturating<u32> as BitOr<Saturating<u32>>>::Output

应用 | 运算符后的结果类型。

fn bitor(
    self,
    other: &Saturating<u32>
) -> <Saturating<u32> as BitOr<Saturating<u32>>>::Output

执行 | 操作。

impl BitOr<&'_ Saturating<u64>> for Saturating<u64>

type Output = <Saturating<u64> as BitOr<Saturating<u64>>>::Output

应用 | 运算符后的结果类型。

fn bitor(
    self,
    other: &Saturating<u64>
) -> <Saturating<u64> as BitOr<Saturating<u64>>>::Output

执行 | 操作。

impl BitOr<&'_ Saturating<u64>> for &Saturating<u64>

type Output = <Saturating<u64> as BitOr<Saturating<u64>>>::Output

应用 | 运算符后的结果类型。

fn bitor(
    self,
    other: &Saturating<u64>
) -> <Saturating<u64> as BitOr<Saturating<u64>>>::Output

执行 | 操作。

impl BitOr<&'_ Saturating<u8>> for Saturating<u8>

type Output = <Saturating<u8> as BitOr<Saturating<u8>>>::Output

应用 | 运算符后的结果类型。

fn bitor(
    self,
    other: &Saturating<u8>
) -> <Saturating<u8> as BitOr<Saturating<u8>>>::Output

执行 | 操作。

impl BitOr<&'_ Saturating<u8>> for &Saturating<u8>

type Output = <Saturating<u8> as BitOr<Saturating<u8>>>::Output

应用 | 运算符后的结果类型。

fn bitor(
    self,
    other: &Saturating<u8>
) -> <Saturating<u8> as BitOr<Saturating<u8>>>::Output

执行 | 操作。

impl BitOr<&'_ Saturating<usize>> for Saturating<usize>

type Output = <Saturating<usize> as BitOr<Saturating<usize>>>::Output

应用 | 运算符后的结果类型。

fn bitor(
    self,
    other: &Saturating<usize>
) -> <Saturating<usize> as BitOr<Saturating<usize>>>::Output

执行 | 操作。

impl BitOr<&'_ Saturating<usize>> for &Saturating<usize>

type Output = <Saturating<usize> as BitOr<Saturating<usize>>>::Output

应用 | 运算符后的结果类型。

fn bitor(
    self,
    other: &Saturating<usize>
) -> <Saturating<usize> as BitOr<Saturating<usize>>>::Output

执行 | 操作。

impl BitOr<Saturating<i128>> for Saturating<i128>

type Output = Saturating<i128>

应用 | 运算符后的结果类型。

fn bitor(self, other: Saturating<i128>) -> Saturating<i128>

执行 | 操作。

impl<'a> BitOr<Saturating<i128>> for &'a Saturating<i128>

type Output = <Saturating<i128> as BitOr<Saturating<i128>>>::Output

应用 | 运算符后的结果类型。

fn bitor(
    self,
    other: Saturating<i128>
) -> <Saturating<i128> as BitOr<Saturating<i128>>>::Output

执行 | 操作。

impl BitOr<Saturating<i16>> for Saturating<i16>

type Output = Saturating<i16>

应用 | 运算符后的结果类型。

fn bitor(self, other: Saturating<i16>) -> Saturating<i16>

执行 | 操作。

impl<'a> BitOr<Saturating<i16>> for &'a Saturating<i16>

type Output = <Saturating<i16> as BitOr<Saturating<i16>>>::Output

应用 | 运算符后的结果类型。

fn bitor(
    self,
    other: Saturating<i16>
) -> <Saturating<i16> as BitOr<Saturating<i16>>>::Output

执行 | 操作。

impl BitOr<Saturating<i32>> for Saturating<i32>

type Output = Saturating<i32>

应用 | 运算符后的结果类型。

fn bitor(self, other: Saturating<i32>) -> Saturating<i32>

执行 | 操作。

impl<'a> BitOr<Saturating<i32>> for &'a Saturating<i32>

type Output = <Saturating<i32> as BitOr<Saturating<i32>>>::Output

应用 | 运算符后的结果类型。

fn bitor(
    self,
    other: Saturating<i32>
) -> <Saturating<i32> as BitOr<Saturating<i32>>>::Output

执行 | 操作。

impl BitOr<Saturating<i64>> for Saturating<i64>

type Output = Saturating<i64>

应用 | 运算符后的结果类型。

fn bitor(self, other: Saturating<i64>) -> Saturating<i64>

执行 | 操作。

impl<'a> BitOr<Saturating<i64>> for &'a Saturating<i64>

type Output = <Saturating<i64> as BitOr<Saturating<i64>>>::Output

应用 | 运算符后的结果类型。

fn bitor(
    self,
    other: Saturating<i64>
) -> <Saturating<i64> as BitOr<Saturating<i64>>>::Output

执行 | 操作。

impl BitOr<Saturating<i8>> for Saturating<i8>

type Output = Saturating<i8>

应用 | 运算符后的结果类型。

fn bitor(self, other: Saturating<i8>) -> Saturating<i8>

执行 | 操作。

impl<'a> BitOr<Saturating<i8>> for &'a Saturating<i8>

type Output = <Saturating<i8> as BitOr<Saturating<i8>>>::Output

应用 | 运算符后的结果类型。

fn bitor(
    self,
    other: Saturating<i8>
) -> <Saturating<i8> as BitOr<Saturating<i8>>>::Output

执行 | 操作。

impl BitOr<Saturating<isize>> for Saturating<isize>

type Output = Saturating<isize>

应用 | 运算符后的结果类型。

fn bitor(self, other: Saturating<isize>) -> Saturating<isize>

执行 | 操作。

impl<'a> BitOr<Saturating<isize>> for &'a Saturating<isize>

type Output = <Saturating<isize> as BitOr<Saturating<isize>>>::Output

应用 | 运算符后的结果类型。

fn bitor(
    self,
    other: Saturating<isize>
) -> <Saturating<isize> as BitOr<Saturating<isize>>>::Output

执行 | 操作。

impl BitOr<Saturating<u128>> for Saturating<u128>

type Output = Saturating<u128>

应用 | 运算符后的结果类型。

fn bitor(self, other: Saturating<u128>) -> Saturating<u128>

执行 | 操作。

impl<'a> BitOr<Saturating<u128>> for &'a Saturating<u128>

type Output = <Saturating<u128> as BitOr<Saturating<u128>>>::Output

应用 | 运算符后的结果类型。

fn bitor(
    self,
    other: Saturating<u128>
) -> <Saturating<u128> as BitOr<Saturating<u128>>>::Output

执行 | 操作。

impl BitOr<Saturating<u16>> for Saturating<u16>

type Output = Saturating<u16>

应用 | 运算符后的结果类型。

fn bitor(self, other: Saturating<u16>) -> Saturating<u16>

执行 | 操作。

impl<'a> BitOr<Saturating<u16>> for &'a Saturating<u16>

type Output = <Saturating<u16> as BitOr<Saturating<u16>>>::Output

应用 | 运算符后的结果类型。

fn bitor(
    self,
    other: Saturating<u16>
) -> <Saturating<u16> as BitOr<Saturating<u16>>>::Output

执行 | 操作。

impl BitOr<Saturating<u32>> for Saturating<u32>

type Output = Saturating<u32>

应用 | 运算符后的结果类型。

fn bitor(self, other: Saturating<u32>) -> Saturating<u32>

执行 | 操作。

impl<'a> BitOr<Saturating<u32>> for &'a Saturating<u32>

type Output = <Saturating<u32> as BitOr<Saturating<u32>>>::Output

应用 | 运算符后的结果类型。

fn bitor(
    self,
    other: Saturating<u32>
) -> <Saturating<u32> as BitOr<Saturating<u32>>>::Output

执行 | 操作。

impl BitOr<Saturating<u64>> for Saturating<u64>

type Output = Saturating<u64>

应用 | 运算符后的结果类型。

fn bitor(self, other: Saturating<u64>) -> Saturating<u64>

执行 | 操作。

impl<'a> BitOr<Saturating<u64>> for &'a Saturating<u64>

type Output = <Saturating<u64> as BitOr<Saturating<u64>>>::Output

应用 | 运算符后的结果类型。

fn bitor(
    self,
    other: Saturating<u64>
) -> <Saturating<u64> as BitOr<Saturating<u64>>>::Output

执行 | 操作。

impl BitOr<Saturating<u8>> for Saturating<u8>

type Output = Saturating<u8>

应用 | 运算符后的结果类型。

fn bitor(self, other: Saturating<u8>) -> Saturating<u8>

执行 | 操作。

impl<'a> BitOr<Saturating<u8>> for &'a Saturating<u8>

type Output = <Saturating<u8> as BitOr<Saturating<u8>>>::Output

应用 | 运算符后的结果类型。

fn bitor(
    self,
    other: Saturating<u8>
) -> <Saturating<u8> as BitOr<Saturating<u8>>>::Output

执行 | 操作。

impl BitOr<Saturating<usize>> for Saturating<usize>

type Output = Saturating<usize>

应用 | 运算符后的结果类型。

fn bitor(self, other: Saturating<usize>) -> Saturating<usize>

执行 | 操作。

impl<'a> BitOr<Saturating<usize>> for &'a Saturating<usize>

type Output = <Saturating<usize> as BitOr<Saturating<usize>>>::Output

应用 | 运算符后的结果类型。

fn bitor(
    self,
    other: Saturating<usize>
) -> <Saturating<usize> as BitOr<Saturating<usize>>>::Output

执行 | 操作。

impl BitOrAssign<&'_ Saturating<i128>> for Saturating<i128>

fn bitor_assign(&mut self, other: &Saturating<i128>)

执行 |= 操作。

impl BitOrAssign<&'_ Saturating<i16>> for Saturating<i16>

fn bitor_assign(&mut self, other: &Saturating<i16>)

执行 |= 操作。

impl BitOrAssign<&'_ Saturating<i32>> for Saturating<i32>

fn bitor_assign(&mut self, other: &Saturating<i32>)

执行 |= 操作。

impl BitOrAssign<&'_ Saturating<i64>> for Saturating<i64>

fn bitor_assign(&mut self, other: &Saturating<i64>)

执行 |= 操作。

impl BitOrAssign<&'_ Saturating<i8>> for Saturating<i8>

fn bitor_assign(&mut self, other: &Saturating<i8>)

执行 |= 操作。

impl BitOrAssign<&'_ Saturating<isize>> for Saturating<isize>

fn bitor_assign(&mut self, other: &Saturating<isize>)

执行 |= 操作。

impl BitOrAssign<&'_ Saturating<u128>> for Saturating<u128>

fn bitor_assign(&mut self, other: &Saturating<u128>)

执行 |= 操作。

impl BitOrAssign<&'_ Saturating<u16>> for Saturating<u16>

fn bitor_assign(&mut self, other: &Saturating<u16>)

执行 |= 操作。

impl BitOrAssign<&'_ Saturating<u32>> for Saturating<u32>

fn bitor_assign(&mut self, other: &Saturating<u32>)

执行 |= 操作。

impl BitOrAssign<&'_ Saturating<u64>> for Saturating<u64>

fn bitor_assign(&mut self, other: &Saturating<u64>)

执行 |= 操作。

impl BitOrAssign<&'_ Saturating<u8>> for Saturating<u8>

fn bitor_assign(&mut self, other: &Saturating<u8>)

执行 |= 操作。

impl BitOrAssign<&'_ Saturating<usize>> for Saturating<usize>

fn bitor_assign(&mut self, other: &Saturating<usize>)

执行 |= 操作。

impl BitOrAssign<Saturating<i128>> for Saturating<i128>

fn bitor_assign(&mut self, other: Saturating<i128>)

执行 |= 操作。

impl BitOrAssign<Saturating<i16>> for Saturating<i16>

fn bitor_assign(&mut self, other: Saturating<i16>)

执行 |= 操作。

impl BitOrAssign<Saturating<i32>> for Saturating<i32>

fn bitor_assign(&mut self, other: Saturating<i32>)

执行 |= 操作。

impl BitOrAssign<Saturating<i64>> for Saturating<i64>

fn bitor_assign(&mut self, other: Saturating<i64>)

执行 |= 操作。

impl BitOrAssign<Saturating<i8>> for Saturating<i8>

fn bitor_assign(&mut self, other: Saturating<i8>)

执行 |= 操作。

impl BitOrAssign<Saturating<isize>> for Saturating<isize>

fn bitor_assign(&mut self, other: Saturating<isize>)

执行 |= 操作。

impl BitOrAssign<Saturating<u128>> for Saturating<u128>

fn bitor_assign(&mut self, other: Saturating<u128>)

执行 |= 操作。

impl BitOrAssign<Saturating<u16>> for Saturating<u16>

fn bitor_assign(&mut self, other: Saturating<u16>)

执行 |= 操作。

impl BitOrAssign<Saturating<u32>> for Saturating<u32>

fn bitor_assign(&mut self, other: Saturating<u32>)

执行 |= 操作。

impl BitOrAssign<Saturating<u64>> for Saturating<u64>

fn bitor_assign(&mut self, other: Saturating<u64>)

执行 |= 操作。

impl BitOrAssign<Saturating<u8>> for Saturating<u8>

fn bitor_assign(&mut self, other: Saturating<u8>)

执行 |= 操作。

impl BitOrAssign<Saturating<usize>> for Saturating<usize>

fn bitor_assign(&mut self, other: Saturating<usize>)

执行 |= 操作。

impl BitXor<&'_ Saturating<i128>> for Saturating<i128>

type Output = <Saturating<i128> as BitXor<Saturating<i128>>>::Output

应用 ^ 运算符后的结果类型。

fn bitxor(
    self,
    other: &Saturating<i128>
) -> <Saturating<i128> as BitXor<Saturating<i128>>>::Output

执行 ^ 操作。

impl BitXor<&'_ Saturating<i128>> for &Saturating<i128>

type Output = <Saturating<i128> as BitXor<Saturating<i128>>>::Output

应用 ^ 运算符后的结果类型。

fn bitxor(
    self,
    other: &Saturating<i128>
) -> <Saturating<i128> as BitXor<Saturating<i128>>>::Output

执行 ^ 操作。

impl BitXor<&'_ Saturating<i16>> for Saturating<i16>

type Output = <Saturating<i16> as BitXor<Saturating<i16>>>::Output

应用 ^ 运算符后的结果类型。

fn bitxor(
    self,
    other: &Saturating<i16>
) -> <Saturating<i16> as BitXor<Saturating<i16>>>::Output

执行 ^ 操作。

impl BitXor<&'_ Saturating<i16>> for &Saturating<i16>

type Output = <Saturating<i16> as BitXor<Saturating<i16>>>::Output

应用 ^ 运算符后的结果类型。

fn bitxor(
    self,
    other: &Saturating<i16>
) -> <Saturating<i16> as BitXor<Saturating<i16>>>::Output

执行 ^ 操作。

impl BitXor<&'_ Saturating<i32>> for Saturating<i32>

type Output = <Saturating<i32> as BitXor<Saturating<i32>>>::Output

应用 ^ 运算符后的结果类型。

fn bitxor(
    self,
    other: &Saturating<i32>
) -> <Saturating<i32> as BitXor<Saturating<i32>>>::Output

执行 ^ 操作。

impl BitXor<&'_ Saturating<i32>> for &Saturating<i32>

type Output = <Saturating<i32> as BitXor<Saturating<i32>>>::Output

应用 ^ 运算符后的结果类型。

fn bitxor(
    self,
    other: &Saturating<i32>
) -> <Saturating<i32> as BitXor<Saturating<i32>>>::Output

执行 ^ 操作。

impl BitXor<&'_ Saturating<i64>> for Saturating<i64>

type Output = <Saturating<i64> as BitXor<Saturating<i64>>>::Output

应用 ^ 运算符后的结果类型。

fn bitxor(
    self,
    other: &Saturating<i64>
) -> <Saturating<i64> as BitXor<Saturating<i64>>>::Output

执行 ^ 操作。

impl BitXor<&'_ Saturating<i64>> for &Saturating<i64>

type Output = <Saturating<i64> as BitXor<Saturating<i64>>>::Output

应用 ^ 运算符后的结果类型。

fn bitxor(
    self,
    other: &Saturating<i64>
) -> <Saturating<i64> as BitXor<Saturating<i64>>>::Output

执行 ^ 操作。

impl BitXor<&'_ Saturating<i8>> for Saturating<i8>

type Output = <Saturating<i8> as BitXor<Saturating<i8>>>::Output

应用 ^ 运算符后的结果类型。

fn bitxor(
    self,
    other: &Saturating<i8>
) -> <Saturating<i8> as BitXor<Saturating<i8>>>::Output

执行 ^ 操作。

impl BitXor<&'_ Saturating<i8>> for &Saturating<i8>

type Output = <Saturating<i8> as BitXor<Saturating<i8>>>::Output

应用 ^ 运算符后的结果类型。

fn bitxor(
    self,
    other: &Saturating<i8>
) -> <Saturating<i8> as BitXor<Saturating<i8>>>::Output

执行 ^ 操作。

impl BitXor<&'_ Saturating<isize>> for Saturating<isize>

type Output = <Saturating<isize> as BitXor<Saturating<isize>>>::Output

应用 ^ 运算符后的结果类型。

fn bitxor(
    self,
    other: &Saturating<isize>
) -> <Saturating<isize> as BitXor<Saturating<isize>>>::Output

执行 ^ 操作。

impl BitXor<&'_ Saturating<isize>> for &Saturating<isize>

type Output = <Saturating<isize> as BitXor<Saturating<isize>>>::Output

应用 ^ 运算符后的结果类型。

fn bitxor(
    self,
    other: &Saturating<isize>
) -> <Saturating<isize> as BitXor<Saturating<isize>>>::Output

执行 ^ 操作。

impl BitXor<&'_ Saturating<u128>> for Saturating<u128>

type Output = <Saturating<u128> as BitXor<Saturating<u128>>>::Output

应用 ^ 运算符后的结果类型。

fn bitxor(
    self,
    other: &Saturating<u128>
) -> <Saturating<u128> as BitXor<Saturating<u128>>>::Output

执行 ^ 操作。

impl BitXor<&'_ Saturating<u128>> for &Saturating<u128>

type Output = <Saturating<u128> as BitXor<Saturating<u128>>>::Output

应用 ^ 运算符后的结果类型。

fn bitxor(
    self,
    other: &Saturating<u128>
) -> <Saturating<u128> as BitXor<Saturating<u128>>>::Output

执行 ^ 操作。

impl BitXor<&'_ Saturating<u16>> for Saturating<u16>

type Output = <Saturating<u16> as BitXor<Saturating<u16>>>::Output

应用 ^ 运算符后的结果类型。

fn bitxor(
    self,
    other: &Saturating<u16>
) -> <Saturating<u16> as BitXor<Saturating<u16>>>::Output

执行 ^ 操作。

impl BitXor<&'_ Saturating<u16>> for &Saturating<u16>

type Output = <Saturating<u16> as BitXor<Saturating<u16>>>::Output

应用 ^ 运算符后的结果类型。

fn bitxor(
    self,
    other: &Saturating<u16>
) -> <Saturating<u16> as BitXor<Saturating<u16>>>::Output

执行 ^ 操作。

impl BitXor<&'_ Saturating<u32>> for Saturating<u32>

type Output = <Saturating<u32> as BitXor<Saturating<u32>>>::Output

应用 ^ 运算符后的结果类型。

fn bitxor(
    self,
    other: &Saturating<u32>
) -> <Saturating<u32> as BitXor<Saturating<u32>>>::Output

执行 ^ 操作。

impl BitXor<&'_ Saturating<u32>> for &Saturating<u32>

type Output = <Saturating<u32> as BitXor<Saturating<u32>>>::Output

应用 ^ 运算符后的结果类型。

fn bitxor(
    self,
    other: &Saturating<u32>
) -> <Saturating<u32> as BitXor<Saturating<u32>>>::Output

执行 ^ 操作。

impl BitXor<&'_ Saturating<u64>> for Saturating<u64>

type Output = <Saturating<u64> as BitXor<Saturating<u64>>>::Output

应用 ^ 运算符后的结果类型。

fn bitxor(
    self,
    other: &Saturating<u64>
) -> <Saturating<u64> as BitXor<Saturating<u64>>>::Output

执行 ^ 操作。

impl BitXor<&'_ Saturating<u64>> for &Saturating<u64>

type Output = <Saturating<u64> as BitXor<Saturating<u64>>>::Output

应用 ^ 运算符后的结果类型。

fn bitxor(
    self,
    other: &Saturating<u64>
) -> <Saturating<u64> as BitXor<Saturating<u64>>>::Output

执行 ^ 操作。

impl BitXor<&'_ Saturating<u8>> for Saturating<u8>

type Output = <Saturating<u8> as BitXor<Saturating<u8>>>::Output

应用 ^ 运算符后的结果类型。

fn bitxor(
    self,
    other: &Saturating<u8>
) -> <Saturating<u8> as BitXor<Saturating<u8>>>::Output

执行 ^ 操作。

impl BitXor<&'_ Saturating<u8>> for &Saturating<u8>

type Output = <Saturating<u8> as BitXor<Saturating<u8>>>::Output

应用 ^ 运算符后的结果类型。

fn bitxor(
    self,
    other: &Saturating<u8>
) -> <Saturating<u8> as BitXor<Saturating<u8>>>::Output

执行 ^ 操作。

impl BitXor<&'_ Saturating<usize>> for Saturating<usize>

type Output = <Saturating<usize> as BitXor<Saturating<usize>>>::Output

应用 ^ 运算符后的结果类型。

fn bitxor(
    self,
    other: &Saturating<usize>
) -> <Saturating<usize> as BitXor<Saturating<usize>>>::Output

执行 ^ 操作。

impl BitXor<&'_ Saturating<usize>> for &Saturating<usize>

type Output = <Saturating<usize> as BitXor<Saturating<usize>>>::Output

应用 ^ 运算符后的结果类型。

fn bitxor(
    self,
    other: &Saturating<usize>
) -> <Saturating<usize> as BitXor<Saturating<usize>>>::Output

执行 ^ 操作。

impl BitXor<Saturating<i128>> for Saturating<i128>

type Output = Saturating<i128>

应用 ^ 运算符后的结果类型。

fn bitxor(self, other: Saturating<i128>) -> Saturating<i128>

执行 ^ 操作。

impl<'a> BitXor<Saturating<i128>> for &'a Saturating<i128>

type Output = <Saturating<i128> as BitXor<Saturating<i128>>>::Output

应用 ^ 运算符后的结果类型。

fn bitxor(
    self,
    other: Saturating<i128>
) -> <Saturating<i128> as BitXor<Saturating<i128>>>::Output

执行 ^ 操作。

impl BitXor<Saturating<i16>> for Saturating<i16>

type Output = Saturating<i16>

应用 ^ 运算符后的结果类型。

fn bitxor(self, other: Saturating<i16>) -> Saturating<i16>

执行 ^ 操作。

impl<'a> BitXor<Saturating<i16>> for &'a Saturating<i16>

type Output = <Saturating<i16> as BitXor<Saturating<i16>>>::Output

应用 ^ 运算符后的结果类型。

fn bitxor(
    self,
    other: Saturating<i16>
) -> <Saturating<i16> as BitXor<Saturating<i16>>>::Output

执行 ^ 操作。

impl BitXor<Saturating<i32>> for Saturating<i32>

type Output = Saturating<i32>

应用 ^ 运算符后的结果类型。

fn bitxor(self, other: Saturating<i32>) -> Saturating<i32>

执行 ^ 操作。

impl<'a> BitXor<Saturating<i32>> for &'a Saturating<i32>

type Output = <Saturating<i32> as BitXor<Saturating<i32>>>::Output

应用 ^ 运算符后的结果类型。

fn bitxor(
    self,
    other: Saturating<i32>
) -> <Saturating<i32> as BitXor<Saturating<i32>>>::Output

执行 ^ 操作。

impl BitXor<Saturating<i64>> for Saturating<i64>

type Output = Saturating<i64>

应用 ^ 运算符后的结果类型。

fn bitxor(self, other: Saturating<i64>) -> Saturating<i64>

执行 ^ 操作。

impl<'a> BitXor<Saturating<i64>> for &'a Saturating<i64>

type Output = <Saturating<i64> as BitXor<Saturating<i64>>>::Output

应用 ^ 运算符后的结果类型。

fn bitxor(
    self,
    other: Saturating<i64>
) -> <Saturating<i64> as BitXor<Saturating<i64>>>::Output

执行 ^ 操作。

impl BitXor<Saturating<i8>> for Saturating<i8>

type Output = Saturating<i8>

应用 ^ 运算符后的结果类型。

fn bitxor(self, other: Saturating<i8>) -> Saturating<i8>

执行 ^ 操作。

impl<'a> BitXor<Saturating<i8>> for &'a Saturating<i8>

type Output = <Saturating<i8> as BitXor<Saturating<i8>>>::Output

应用 ^ 运算符后的结果类型。

fn bitxor(
    self,
    other: Saturating<i8>
) -> <Saturating<i8> as BitXor<Saturating<i8>>>::Output

执行 ^ 操作。

impl BitXor<Saturating<isize>> for Saturating<isize>

type Output = Saturating<isize>

应用 ^ 运算符后的结果类型。

fn bitxor(self, other: Saturating<isize>) -> Saturating<isize>

执行 ^ 操作。

impl<'a> BitXor<Saturating<isize>> for &'a Saturating<isize>

type Output = <Saturating<isize> as BitXor<Saturating<isize>>>::Output

应用 ^ 运算符后的结果类型。

fn bitxor(
    self,
    other: Saturating<isize>
) -> <Saturating<isize> as BitXor<Saturating<isize>>>::Output

执行 ^ 操作。

impl BitXor<Saturating<u128>> for Saturating<u128>

type Output = Saturating<u128>

应用 ^ 运算符后的结果类型。

fn bitxor(self, other: Saturating<u128>) -> Saturating<u128>

执行 ^ 操作。

impl<'a> BitXor<Saturating<u128>> for &'a Saturating<u128>

type Output = <Saturating<u128> as BitXor<Saturating<u128>>>::Output

应用 ^ 运算符后的结果类型。

fn bitxor(
    self,
    other: Saturating<u128>
) -> <Saturating<u128> as BitXor<Saturating<u128>>>::Output

执行 ^ 操作。

impl BitXor<Saturating<u16>> for Saturating<u16>

type Output = Saturating<u16>

应用 ^ 运算符后的结果类型。

fn bitxor(self, other: Saturating<u16>) -> Saturating<u16>

执行 ^ 操作。

impl<'a> BitXor<Saturating<u16>> for &'a Saturating<u16>

type Output = <Saturating<u16> as BitXor<Saturating<u16>>>::Output

应用 ^ 运算符后的结果类型。

fn bitxor(
    self,
    other: Saturating<u16>
) -> <Saturating<u16> as BitXor<Saturating<u16>>>::Output

执行 ^ 操作。

impl BitXor<Saturating<u32>> for Saturating<u32>

type Output = Saturating<u32>

应用 ^ 运算符后的结果类型。

fn bitxor(self, other: Saturating<u32>) -> Saturating<u32>

执行 ^ 操作。

impl<'a> BitXor<Saturating<u32>> for &'a Saturating<u32>

type Output = <Saturating<u32> as BitXor<Saturating<u32>>>::Output

应用 ^ 运算符后的结果类型。

fn bitxor(
    self,
    other: Saturating<u32>
) -> <Saturating<u32> as BitXor<Saturating<u32>>>::Output

执行 ^ 操作。

impl BitXor<Saturating<u64>> for Saturating<u64>

type Output = Saturating<u64>

应用 ^ 运算符后的结果类型。

fn bitxor(self, other: Saturating<u64>) -> Saturating<u64>

执行 ^ 操作。

impl<'a> BitXor<Saturating<u64>> for &'a Saturating<u64>

type Output = <Saturating<u64> as BitXor<Saturating<u64>>>::Output

应用 ^ 运算符后的结果类型。

fn bitxor(
    self,
    other: Saturating<u64>
) -> <Saturating<u64> as BitXor<Saturating<u64>>>::Output

执行 ^ 操作。

impl BitXor<Saturating<u8>> for Saturating<u8>

type Output = Saturating<u8>

应用 ^ 运算符后的结果类型。

fn bitxor(self, other: Saturating<u8>) -> Saturating<u8>

执行 ^ 操作。

impl<'a> BitXor<Saturating<u8>> for &'a Saturating<u8>

type Output = <Saturating<u8> as BitXor<Saturating<u8>>>::Output

应用 ^ 运算符后的结果类型。

fn bitxor(
    self,
    other: Saturating<u8>
) -> <Saturating<u8> as BitXor<Saturating<u8>>>::Output

执行 ^ 操作。

impl BitXor<Saturating<usize>> for Saturating<usize>

type Output = Saturating<usize>

应用 ^ 运算符后的结果类型。

fn bitxor(self, other: Saturating<usize>) -> Saturating<usize>

执行 ^ 操作。

impl<'a> BitXor<Saturating<usize>> for &'a Saturating<usize>

type Output = <Saturating<usize> as BitXor<Saturating<usize>>>::Output

应用 ^ 运算符后的结果类型。

fn bitxor(
    self,
    other: Saturating<usize>
) -> <Saturating<usize> as BitXor<Saturating<usize>>>::Output

执行 ^ 操作。

impl BitXorAssign<&'_ Saturating<i128>> for Saturating<i128>

fn bitxor_assign(&mut self, other: &Saturating<i128>)

执行 ^= 操作。

impl BitXorAssign<&'_ Saturating<i16>> for Saturating<i16>

fn bitxor_assign(&mut self, other: &Saturating<i16>)

执行 ^= 操作。

impl BitXorAssign<&'_ Saturating<i32>> for Saturating<i32>

fn bitxor_assign(&mut self, other: &Saturating<i32>)

执行 ^= 操作。

impl BitXorAssign<&'_ Saturating<i64>> for Saturating<i64>

fn bitxor_assign(&mut self, other: &Saturating<i64>)

执行 ^= 操作。

impl BitXorAssign<&'_ Saturating<i8>> for Saturating<i8>

fn bitxor_assign(&mut self, other: &Saturating<i8>)

执行 ^= 操作。

impl BitXorAssign<&'_ Saturating<isize>> for Saturating<isize>

fn bitxor_assign(&mut self, other: &Saturating<isize>)

执行 ^= 操作。

impl BitXorAssign<&'_ Saturating<u128>> for Saturating<u128>

fn bitxor_assign(&mut self, other: &Saturating<u128>)

执行 ^= 操作。

impl BitXorAssign<&'_ Saturating<u16>> for Saturating<u16>

fn bitxor_assign(&mut self, other: &Saturating<u16>)

执行 ^= 操作。

impl BitXorAssign<&'_ Saturating<u32>> for Saturating<u32>

fn bitxor_assign(&mut self, other: &Saturating<u32>)

执行 ^= 操作。

impl BitXorAssign<&'_ Saturating<u64>> for Saturating<u64>

fn bitxor_assign(&mut self, other: &Saturating<u64>)

执行 ^= 操作。

impl BitXorAssign<&'_ Saturating<u8>> for Saturating<u8>

fn bitxor_assign(&mut self, other: &Saturating<u8>)

执行 ^= 操作。

impl BitXorAssign<&'_ Saturating<usize>> for Saturating<usize>

fn bitxor_assign(&mut self, other: &Saturating<usize>)

执行 ^= 操作。

impl BitXorAssign<Saturating<i128>> for Saturating<i128>

fn bitxor_assign(&mut self, other: Saturating<i128>)

执行 ^= 操作。

impl BitXorAssign<Saturating<i16>> for Saturating<i16>

fn bitxor_assign(&mut self, other: Saturating<i16>)

执行 ^= 操作。

impl BitXorAssign<Saturating<i32>> for Saturating<i32>

fn bitxor_assign(&mut self, other: Saturating<i32>)

执行 ^= 操作。

impl BitXorAssign<Saturating<i64>> for Saturating<i64>

fn bitxor_assign(&mut self, other: Saturating<i64>)

执行 ^= 操作。

impl BitXorAssign<Saturating<i8>> for Saturating<i8>

fn bitxor_assign(&mut self, other: Saturating<i8>)

执行 ^= 操作。

impl BitXorAssign<Saturating<isize>> for Saturating<isize>

fn bitxor_assign(&mut self, other: Saturating<isize>)

执行 ^= 操作。

impl BitXorAssign<Saturating<u128>> for Saturating<u128>

fn bitxor_assign(&mut self, other: Saturating<u128>)

执行 ^= 操作。

impl BitXorAssign<Saturating<u16>> for Saturating<u16>

fn bitxor_assign(&mut self, other: Saturating<u16>)

执行 ^= 操作。

impl BitXorAssign<Saturating<u32>> for Saturating<u32>

fn bitxor_assign(&mut self, other: Saturating<u32>)

执行 ^= 操作。

impl BitXorAssign<Saturating<u64>> for Saturating<u64>

fn bitxor_assign(&mut self, other: Saturating<u64>)

执行 ^= 操作。

impl BitXorAssign<Saturating<u8>> for Saturating<u8>

fn bitxor_assign(&mut self, other: Saturating<u8>)

执行 ^= 操作。

impl BitXorAssign<Saturating<usize>> for Saturating<usize>

fn bitxor_assign(&mut self, other: Saturating<usize>)

执行 ^= 操作。

impl<T: Clone> Clone for Saturating<T>

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

返回值的副本。

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

从 source 执行复制分配。

impl<T: Debug> Debug for Saturating<T>

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

使用给定的格式化程序格式化该值。

impl<T: Default> Default for Saturating<T>

fn default() -> Saturating<T>

返回类型的 “默认值”。

impl<T: Display> Display for Saturating<T>

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

使用给定的格式化程序格式化该值。

impl Div<&'_ Saturating<i128>> for Saturating<i128>

type Output = <Saturating<i128> as Div<Saturating<i128>>>::Output

应用 / 运算符后的结果类型。

fn div(
    self,
    other: &Saturating<i128>
) -> <Saturating<i128> as Div<Saturating<i128>>>::Output

执行 / 操作。

impl Div<&'_ Saturating<i128>> for &Saturating<i128>

type Output = <Saturating<i128> as Div<Saturating<i128>>>::Output

应用 / 运算符后的结果类型。

fn div(
    self,
    other: &Saturating<i128>
) -> <Saturating<i128> as Div<Saturating<i128>>>::Output

执行 / 操作。

impl Div<&'_ Saturating<i16>> for Saturating<i16>

type Output = <Saturating<i16> as Div<Saturating<i16>>>::Output

应用 / 运算符后的结果类型。

fn div(
    self,
    other: &Saturating<i16>
) -> <Saturating<i16> as Div<Saturating<i16>>>::Output

执行 / 操作。

impl Div<&'_ Saturating<i16>> for &Saturating<i16>

type Output = <Saturating<i16> as Div<Saturating<i16>>>::Output

应用 / 运算符后的结果类型。

fn div(
    self,
    other: &Saturating<i16>
) -> <Saturating<i16> as Div<Saturating<i16>>>::Output

执行 / 操作。

impl Div<&'_ Saturating<i32>> for Saturating<i32>

type Output = <Saturating<i32> as Div<Saturating<i32>>>::Output

应用 / 运算符后的结果类型。

fn div(
    self,
    other: &Saturating<i32>
) -> <Saturating<i32> as Div<Saturating<i32>>>::Output

执行 / 操作。

impl Div<&'_ Saturating<i32>> for &Saturating<i32>

type Output = <Saturating<i32> as Div<Saturating<i32>>>::Output

应用 / 运算符后的结果类型。

fn div(
    self,
    other: &Saturating<i32>
) -> <Saturating<i32> as Div<Saturating<i32>>>::Output

执行 / 操作。

impl Div<&'_ Saturating<i64>> for Saturating<i64>

type Output = <Saturating<i64> as Div<Saturating<i64>>>::Output

应用 / 运算符后的结果类型。

fn div(
    self,
    other: &Saturating<i64>
) -> <Saturating<i64> as Div<Saturating<i64>>>::Output

执行 / 操作。

impl Div<&'_ Saturating<i64>> for &Saturating<i64>

type Output = <Saturating<i64> as Div<Saturating<i64>>>::Output

应用 / 运算符后的结果类型。

fn div(
    self,
    other: &Saturating<i64>
) -> <Saturating<i64> as Div<Saturating<i64>>>::Output

执行 / 操作。

impl Div<&'_ Saturating<i8>> for Saturating<i8>

type Output = <Saturating<i8> as Div<Saturating<i8>>>::Output

应用 / 运算符后的结果类型。

fn div(
    self,
    other: &Saturating<i8>
) -> <Saturating<i8> as Div<Saturating<i8>>>::Output

执行 / 操作。

impl Div<&'_ Saturating<i8>> for &Saturating<i8>

type Output = <Saturating<i8> as Div<Saturating<i8>>>::Output

应用 / 运算符后的结果类型。

fn div(
    self,
    other: &Saturating<i8>
) -> <Saturating<i8> as Div<Saturating<i8>>>::Output

执行 / 操作。

impl Div<&'_ Saturating<isize>> for Saturating<isize>

type Output = <Saturating<isize> as Div<Saturating<isize>>>::Output

应用 / 运算符后的结果类型。

fn div(
    self,
    other: &Saturating<isize>
) -> <Saturating<isize> as Div<Saturating<isize>>>::Output

执行 / 操作。

impl Div<&'_ Saturating<isize>> for &Saturating<isize>

type Output = <Saturating<isize> as Div<Saturating<isize>>>::Output

应用 / 运算符后的结果类型。

fn div(
    self,
    other: &Saturating<isize>
) -> <Saturating<isize> as Div<Saturating<isize>>>::Output

执行 / 操作。

impl Div<&'_ Saturating<u128>> for Saturating<u128>

type Output = <Saturating<u128> as Div<Saturating<u128>>>::Output

应用 / 运算符后的结果类型。

fn div(
    self,
    other: &Saturating<u128>
) -> <Saturating<u128> as Div<Saturating<u128>>>::Output

执行 / 操作。

impl Div<&'_ Saturating<u128>> for &Saturating<u128>

type Output = <Saturating<u128> as Div<Saturating<u128>>>::Output

应用 / 运算符后的结果类型。

fn div(
    self,
    other: &Saturating<u128>
) -> <Saturating<u128> as Div<Saturating<u128>>>::Output

执行 / 操作。

impl Div<&'_ Saturating<u16>> for Saturating<u16>

type Output = <Saturating<u16> as Div<Saturating<u16>>>::Output

应用 / 运算符后的结果类型。

fn div(
    self,
    other: &Saturating<u16>
) -> <Saturating<u16> as Div<Saturating<u16>>>::Output

执行 / 操作。

impl Div<&'_ Saturating<u16>> for &Saturating<u16>

type Output = <Saturating<u16> as Div<Saturating<u16>>>::Output

应用 / 运算符后的结果类型。

fn div(
    self,
    other: &Saturating<u16>
) -> <Saturating<u16> as Div<Saturating<u16>>>::Output

执行 / 操作。

impl Div<&'_ Saturating<u32>> for Saturating<u32>

type Output = <Saturating<u32> as Div<Saturating<u32>>>::Output

应用 / 运算符后的结果类型。

fn div(
    self,
    other: &Saturating<u32>
) -> <Saturating<u32> as Div<Saturating<u32>>>::Output

执行 / 操作。

impl Div<&'_ Saturating<u32>> for &Saturating<u32>

type Output = <Saturating<u32> as Div<Saturating<u32>>>::Output

应用 / 运算符后的结果类型。

fn div(
    self,
    other: &Saturating<u32>
) -> <Saturating<u32> as Div<Saturating<u32>>>::Output

执行 / 操作。

impl Div<&'_ Saturating<u64>> for Saturating<u64>

type Output = <Saturating<u64> as Div<Saturating<u64>>>::Output

应用 / 运算符后的结果类型。

fn div(
    self,
    other: &Saturating<u64>
) -> <Saturating<u64> as Div<Saturating<u64>>>::Output

执行 / 操作。

impl Div<&'_ Saturating<u64>> for &Saturating<u64>

type Output = <Saturating<u64> as Div<Saturating<u64>>>::Output

应用 / 运算符后的结果类型。

fn div(
    self,
    other: &Saturating<u64>
) -> <Saturating<u64> as Div<Saturating<u64>>>::Output

执行 / 操作。

impl Div<&'_ Saturating<u8>> for Saturating<u8>

type Output = <Saturating<u8> as Div<Saturating<u8>>>::Output

应用 / 运算符后的结果类型。

fn div(
    self,
    other: &Saturating<u8>
) -> <Saturating<u8> as Div<Saturating<u8>>>::Output

执行 / 操作。

impl Div<&'_ Saturating<u8>> for &Saturating<u8>

type Output = <Saturating<u8> as Div<Saturating<u8>>>::Output

应用 / 运算符后的结果类型。

fn div(
    self,
    other: &Saturating<u8>
) -> <Saturating<u8> as Div<Saturating<u8>>>::Output

执行 / 操作。

impl Div<&'_ Saturating<usize>> for Saturating<usize>

type Output = <Saturating<usize> as Div<Saturating<usize>>>::Output

应用 / 运算符后的结果类型。

fn div(
    self,
    other: &Saturating<usize>
) -> <Saturating<usize> as Div<Saturating<usize>>>::Output

执行 / 操作。

impl Div<&'_ Saturating<usize>> for &Saturating<usize>

type Output = <Saturating<usize> as Div<Saturating<usize>>>::Output

应用 / 运算符后的结果类型。

fn div(
    self,
    other: &Saturating<usize>
) -> <Saturating<usize> as Div<Saturating<usize>>>::Output

执行 / 操作。

impl Div<Saturating<i128>> for Saturating<i128>

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert_eq!(Saturating(2i128), Saturating(5i128) / Saturating(2));
assert_eq!(Saturating(i128::MAX), Saturating(i128::MAX) / Saturating(1));
assert_eq!(Saturating(i128::MIN), Saturating(i128::MIN) / Saturating(1));

#![feature(saturating_int_impl)]
use std::num::Saturating;

let _ = Saturating(0i128) / Saturating(0);

type Output = Saturating<i128>

应用 / 运算符后的结果类型。

fn div(self, other: Saturating<i128>) -> Saturating<i128>

执行 / 操作。

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

type Output = <Saturating<i128> as Div<Saturating<i128>>>::Output

应用 / 运算符后的结果类型。

fn div(
    self,
    other: Saturating<i128>
) -> <Saturating<i128> as Div<Saturating<i128>>>::Output

执行 / 操作。

impl Div<Saturating<i16>> for Saturating<i16>

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert_eq!(Saturating(2i16), Saturating(5i16) / Saturating(2));
assert_eq!(Saturating(i16::MAX), Saturating(i16::MAX) / Saturating(1));
assert_eq!(Saturating(i16::MIN), Saturating(i16::MIN) / Saturating(1));

#![feature(saturating_int_impl)]
use std::num::Saturating;

let _ = Saturating(0i16) / Saturating(0);

type Output = Saturating<i16>

应用 / 运算符后的结果类型。

fn div(self, other: Saturating<i16>) -> Saturating<i16>

执行 / 操作。

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

type Output = <Saturating<i16> as Div<Saturating<i16>>>::Output

应用 / 运算符后的结果类型。

fn div(
    self,
    other: Saturating<i16>
) -> <Saturating<i16> as Div<Saturating<i16>>>::Output

执行 / 操作。

impl Div<Saturating<i32>> for Saturating<i32>

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert_eq!(Saturating(2i32), Saturating(5i32) / Saturating(2));
assert_eq!(Saturating(i32::MAX), Saturating(i32::MAX) / Saturating(1));
assert_eq!(Saturating(i32::MIN), Saturating(i32::MIN) / Saturating(1));

#![feature(saturating_int_impl)]
use std::num::Saturating;

let _ = Saturating(0i32) / Saturating(0);

type Output = Saturating<i32>

应用 / 运算符后的结果类型。

fn div(self, other: Saturating<i32>) -> Saturating<i32>

执行 / 操作。

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

type Output = <Saturating<i32> as Div<Saturating<i32>>>::Output

应用 / 运算符后的结果类型。

fn div(
    self,
    other: Saturating<i32>
) -> <Saturating<i32> as Div<Saturating<i32>>>::Output

执行 / 操作。

impl Div<Saturating<i64>> for Saturating<i64>

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert_eq!(Saturating(2i64), Saturating(5i64) / Saturating(2));
assert_eq!(Saturating(i64::MAX), Saturating(i64::MAX) / Saturating(1));
assert_eq!(Saturating(i64::MIN), Saturating(i64::MIN) / Saturating(1));

#![feature(saturating_int_impl)]
use std::num::Saturating;

let _ = Saturating(0i64) / Saturating(0);

type Output = Saturating<i64>

应用 / 运算符后的结果类型。

fn div(self, other: Saturating<i64>) -> Saturating<i64>

执行 / 操作。

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

type Output = <Saturating<i64> as Div<Saturating<i64>>>::Output

应用 / 运算符后的结果类型。

fn div(
    self,
    other: Saturating<i64>
) -> <Saturating<i64> as Div<Saturating<i64>>>::Output

执行 / 操作。

impl Div<Saturating<i8>> for Saturating<i8>

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert_eq!(Saturating(2i8), Saturating(5i8) / Saturating(2));
assert_eq!(Saturating(i8::MAX), Saturating(i8::MAX) / Saturating(1));
assert_eq!(Saturating(i8::MIN), Saturating(i8::MIN) / Saturating(1));

#![feature(saturating_int_impl)]
use std::num::Saturating;

let _ = Saturating(0i8) / Saturating(0);

type Output = Saturating<i8>

应用 / 运算符后的结果类型。

fn div(self, other: Saturating<i8>) -> Saturating<i8>

执行 / 操作。

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

type Output = <Saturating<i8> as Div<Saturating<i8>>>::Output

应用 / 运算符后的结果类型。

fn div(
    self,
    other: Saturating<i8>
) -> <Saturating<i8> as Div<Saturating<i8>>>::Output

执行 / 操作。

impl Div<Saturating<isize>> for Saturating<isize>

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert_eq!(Saturating(2isize), Saturating(5isize) / Saturating(2));
assert_eq!(Saturating(isize::MAX), Saturating(isize::MAX) / Saturating(1));
assert_eq!(Saturating(isize::MIN), Saturating(isize::MIN) / Saturating(1));

#![feature(saturating_int_impl)]
use std::num::Saturating;

let _ = Saturating(0isize) / Saturating(0);

type Output = Saturating<isize>

应用 / 运算符后的结果类型。

fn div(self, other: Saturating<isize>) -> Saturating<isize>

执行 / 操作。

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

type Output = <Saturating<isize> as Div<Saturating<isize>>>::Output

应用 / 运算符后的结果类型。

fn div(
    self,
    other: Saturating<isize>
) -> <Saturating<isize> as Div<Saturating<isize>>>::Output

执行 / 操作。

impl Div<Saturating<u128>> for Saturating<u128>

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert_eq!(Saturating(2u128), Saturating(5u128) / Saturating(2));
assert_eq!(Saturating(u128::MAX), Saturating(u128::MAX) / Saturating(1));
assert_eq!(Saturating(u128::MIN), Saturating(u128::MIN) / Saturating(1));

#![feature(saturating_int_impl)]
use std::num::Saturating;

let _ = Saturating(0u128) / Saturating(0);

type Output = Saturating<u128>

应用 / 运算符后的结果类型。

fn div(self, other: Saturating<u128>) -> Saturating<u128>

执行 / 操作。

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

type Output = <Saturating<u128> as Div<Saturating<u128>>>::Output

应用 / 运算符后的结果类型。

fn div(
    self,
    other: Saturating<u128>
) -> <Saturating<u128> as Div<Saturating<u128>>>::Output

执行 / 操作。

impl Div<Saturating<u16>> for Saturating<u16>

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert_eq!(Saturating(2u16), Saturating(5u16) / Saturating(2));
assert_eq!(Saturating(u16::MAX), Saturating(u16::MAX) / Saturating(1));
assert_eq!(Saturating(u16::MIN), Saturating(u16::MIN) / Saturating(1));

#![feature(saturating_int_impl)]
use std::num::Saturating;

let _ = Saturating(0u16) / Saturating(0);

type Output = Saturating<u16>

应用 / 运算符后的结果类型。

fn div(self, other: Saturating<u16>) -> Saturating<u16>

执行 / 操作。

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

type Output = <Saturating<u16> as Div<Saturating<u16>>>::Output

应用 / 运算符后的结果类型。

fn div(
    self,
    other: Saturating<u16>
) -> <Saturating<u16> as Div<Saturating<u16>>>::Output

执行 / 操作。

impl Div<Saturating<u32>> for Saturating<u32>

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert_eq!(Saturating(2u32), Saturating(5u32) / Saturating(2));
assert_eq!(Saturating(u32::MAX), Saturating(u32::MAX) / Saturating(1));
assert_eq!(Saturating(u32::MIN), Saturating(u32::MIN) / Saturating(1));

#![feature(saturating_int_impl)]
use std::num::Saturating;

let _ = Saturating(0u32) / Saturating(0);

type Output = Saturating<u32>

应用 / 运算符后的结果类型。

fn div(self, other: Saturating<u32>) -> Saturating<u32>

执行 / 操作。

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

type Output = <Saturating<u32> as Div<Saturating<u32>>>::Output

应用 / 运算符后的结果类型。

fn div(
    self,
    other: Saturating<u32>
) -> <Saturating<u32> as Div<Saturating<u32>>>::Output

执行 / 操作。

impl Div<Saturating<u64>> for Saturating<u64>

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert_eq!(Saturating(2u64), Saturating(5u64) / Saturating(2));
assert_eq!(Saturating(u64::MAX), Saturating(u64::MAX) / Saturating(1));
assert_eq!(Saturating(u64::MIN), Saturating(u64::MIN) / Saturating(1));

#![feature(saturating_int_impl)]
use std::num::Saturating;

let _ = Saturating(0u64) / Saturating(0);

type Output = Saturating<u64>

应用 / 运算符后的结果类型。

fn div(self, other: Saturating<u64>) -> Saturating<u64>

执行 / 操作。

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

type Output = <Saturating<u64> as Div<Saturating<u64>>>::Output

应用 / 运算符后的结果类型。

fn div(
    self,
    other: Saturating<u64>
) -> <Saturating<u64> as Div<Saturating<u64>>>::Output

执行 / 操作。

impl Div<Saturating<u8>> for Saturating<u8>

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert_eq!(Saturating(2u8), Saturating(5u8) / Saturating(2));
assert_eq!(Saturating(u8::MAX), Saturating(u8::MAX) / Saturating(1));
assert_eq!(Saturating(u8::MIN), Saturating(u8::MIN) / Saturating(1));

#![feature(saturating_int_impl)]
use std::num::Saturating;

let _ = Saturating(0u8) / Saturating(0);

type Output = Saturating<u8>

应用 / 运算符后的结果类型。

fn div(self, other: Saturating<u8>) -> Saturating<u8>

执行 / 操作。

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

type Output = <Saturating<u8> as Div<Saturating<u8>>>::Output

应用 / 运算符后的结果类型。

fn div(
    self,
    other: Saturating<u8>
) -> <Saturating<u8> as Div<Saturating<u8>>>::Output

执行 / 操作。

impl Div<Saturating<usize>> for Saturating<usize>

Examples

基本用法：

#![feature(saturating_int_impl)]
use std::num::Saturating;

assert_eq!(Saturating(2usize), Saturating(5usize) / Saturating(2));
assert_eq!(Saturating(usize::MAX), Saturating(usize::MAX) / Saturating(1));
assert_eq!(Saturating(usize::MIN), Saturating(usize::MIN) / Saturating(1));

#![feature(saturating_int_impl)]
use std::num::Saturating;

let _ = Saturating(0usize) / Saturating(0);

type Output = Saturating<usize>

应用 / 运算符后的结果类型。

fn div(self, other: Saturating<usize>) -> Saturating<usize>

执行 / 操作。

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

type Output = <Saturating<usize> as Div<Saturating<usize>>>::Output

应用 / 运算符后的结果类型。

fn div(
    self,
    other: Saturating<usize>
) -> <Saturating<usize> as Div<Saturating<usize>>>::Output

执行 / 操作。

impl DivAssign<&'_ Saturating<i128>> for Saturating<i128>

fn div_assign(&mut self, other: &Saturating<i128>)

执行 /= 操作。

impl DivAssign<&'_ Saturating<i16>> for Saturating<i16>

fn div_assign(&mut self, other: &Saturating<i16>)

执行 /= 操作。

impl DivAssign<&'_ Saturating<i32>> for Saturating<i32>

fn div_assign(&mut self, other: &Saturating<i32>)

执行 /= 操作。

impl DivAssign<&'_ Saturating<i64>> for Saturating<i64>

fn div_assign(&mut self, other: &Saturating<i64>)

执行 /= 操作。

impl DivAssign<&'_ Saturating<i8>> for Saturating<i8>

fn div_assign(&mut self, other: &Saturating<i8>)

执行 /= 操作。

impl DivAssign<&'_ Saturating<isize>> for Saturating<isize>

fn div_assign(&mut self, other: &Saturating<isize>)

执行 /= 操作。

impl DivAssign<&'_ Saturating<u128>> for Saturating<u128>

fn div_assign(&mut self, other: &Saturating<u128>)

执行 /= 操作。

impl DivAssign<&'_ Saturating<u16>> for Saturating<u16>

fn div_assign(&mut self, other: &Saturating<u16>)

执行 /= 操作。

impl DivAssign<&'_ Saturating<u32>> for Saturating<u32>

fn div_assign(&mut self, other: &Saturating<u32>)

执行 /= 操作。

impl DivAssign<&'_ Saturating<u64>> for Saturating<u64>

fn div_assign(&mut self, other: &Saturating<u64>)

执行 /= 操作。

impl DivAssign<&'_ Saturating<u8>> for Saturating<u8>

fn div_assign(&mut self, other: &Saturating<u8>)

执行 /= 操作。

impl DivAssign<&'_ Saturating<usize>> for Saturating<usize>

fn div_assign(&mut self, other: &Saturating<usize>)

执行 /= 操作。

impl DivAssign<Saturating<i128>> for Saturating<i128>

fn div_assign(&mut self, other: Saturating<i128>)

执行 /= 操作。

impl DivAssign<Saturating<i16>> for Saturating<i16>

fn div_assign(&mut self, other: Saturating<i16>)

执行 /= 操作。

impl DivAssign<Saturating<i32>> for Saturating<i32>

fn div_assign(&mut self, other: Saturating<i32>)

执行 /= 操作。

impl DivAssign<Saturating<i64>> for Saturating<i64>

fn div_assign(&mut self, other: Saturating<i64>)

执行 /= 操作。

impl DivAssign<Saturating<i8>> for Saturating<i8>

fn div_assign(&mut self, other: Saturating<i8>)

执行 /= 操作。

impl DivAssign<Saturating<isize>> for Saturating<isize>

fn div_assign(&mut self, other: Saturating<isize>)

执行 /= 操作。

impl DivAssign<Saturating<u128>> for Saturating<u128>

fn div_assign(&mut self, other: Saturating<u128>)

执行 /= 操作。

impl DivAssign<Saturating<u16>> for Saturating<u16>

fn div_assign(&mut self, other: Saturating<u16>)

执行 /= 操作。

impl DivAssign<Saturating<u32>> for Saturating<u32>

fn div_assign(&mut self, other: Saturating<u32>)

执行 /= 操作。

impl DivAssign<Saturating<u64>> for Saturating<u64>

fn div_assign(&mut self, other: Saturating<u64>)

执行 /= 操作。

impl DivAssign<Saturating<u8>> for Saturating<u8>

fn div_assign(&mut self, other: Saturating<u8>)

执行 /= 操作。

impl DivAssign<Saturating<usize>> for Saturating<usize>

fn div_assign(&mut self, other: Saturating<usize>)

执行 /= 操作。

impl<T: Hash> Hash for Saturating<T>

fn hash<__H: Hasher>(&self, state: &mut __H)

将该值输入给定的 Hasher。

fn hash_slice<H: Hasher>(data: &[Self], state: &mut H) where
    Self: Sized, 

将这种类型的切片送入给定的 Hasher 中。

impl<T: LowerHex> LowerHex for Saturating<T>

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

使用给定的格式化程序格式化该值。

impl Mul<&'_ Saturating<i128>> for Saturating<i128>

type Output = <Saturating<i128> as Mul<Saturating<i128>>>::Output

应用 * 运算符后的结果类型。

fn mul(
    self,
    other: &Saturating<i128>
) -> <Saturating<i128> as Mul<Saturating<i128>>>::Output

执行 * 操作。

impl Mul<&'_ Saturating<i128>> for &Saturating<i128>

type Output = <Saturating<i128> as Mul<Saturating<i128>>>::Output

应用 * 运算符后的结果类型。

fn mul(
    self,
    other: &Saturating<i128>
) -> <Saturating<i128> as Mul<Saturating<i128>>>::Output

执行 * 操作。

impl Mul<&'_ Saturating<i16>> for Saturating<i16>

type Output = <Saturating<i16> as Mul<Saturating<i16>>>::Output

应用 * 运算符后的结果类型。

fn mul(
    self,
    other: &Saturating<i16>
) -> <Saturating<i16> as Mul<Saturating<i16>>>::Output

执行 * 操作。

impl Mul<&'_ Saturating<i16>> for &Saturating<i16>

type Output = <Saturating<i16> as Mul<Saturating<i16>>>::Output

应用 * 运算符后的结果类型。

fn mul(
    self,
    other: &Saturating<i16>
) -> <Saturating<i16> as Mul<Saturating<i16>>>::Output

执行 * 操作。

impl Mul<&'_ Saturating<i32>> for Saturating<i32>

type Output = <Saturating<i32> as Mul<Saturating<i32>>>::Output

应用 * 运算符后的结果类型。

fn mul(
    self,
    other: &Saturating<i32>
) -> <Saturating<i32> as Mul<Saturating<i32>>>::Output

执行 * 操作。

impl Mul<&'_ Saturating<i32>> for &Saturating<i32>

type Output = <Saturating<i32> as Mul<Saturating<i32>>>::Output

应用 * 运算符后的结果类型。

fn mul(
    self,
    other: &Saturating<i32>
) -> <Saturating<i32> as Mul<Saturating<i32>>>::Output

执行 * 操作。

impl Mul<&'_ Saturating<i64>> for Saturating<i64>

type Output = <Saturating<i64> as Mul<Saturating<i64>>>::Output

应用 * 运算符后的结果类型。

fn mul(
    self,
    other: &Saturating<i64>
) -> <Saturating<i64> as Mul<Saturating<i64>>>::Output

执行 * 操作。

impl Mul<&'_ Saturating<i64>> for &Saturating<i64>

type Output = <Saturating<i64> as Mul<Saturating<i64>>>::Output

应用 * 运算符后的结果类型。

fn mul(
    self,
    other: &Saturating<i64>
) -> <Saturating<i64> as Mul<Saturating<i64>>>::Output

执行 * 操作。

impl Mul<&'_ Saturating<i8>> for Saturating<i8>

type Output = <Saturating<i8> as Mul<Saturating<i8>>>::Output

应用 * 运算符后的结果类型。

fn mul(
    self,
    other: &Saturating<i8>
) -> <Saturating<i8> as Mul<Saturating<i8>>>::Output

执行 * 操作。

impl Mul<&'_ Saturating<i8>> for &Saturating<i8>

type Output = <Saturating<i8> as Mul<Saturating<i8>>>::Output

应用 * 运算符后的结果类型。

fn mul(
    self,
    other: &Saturating<i8>
) -> <Saturating<i8> as Mul<Saturating<i8>>>::Output

执行 * 操作。

impl Mul<&'_ Saturating<isize>> for Saturating<isize>

type Output = <Saturating<isize> as Mul<Saturating<isize>>>::Output

应用 * 运算符后的结果类型。

fn mul(
    self,
    other: &Saturating<isize>
) -> <Saturating<isize> as Mul<Saturating<isize>>>::Output

执行 * 操作。

impl Mul<&'_ Saturating<isize>> for &Saturating<isize>

type Output = <Saturating<isize> as Mul<Saturating<isize>>>::Output

应用 * 运算符后的结果类型。

fn mul(
    self,
    other: &Saturating<isize>
) -> <Saturating<isize> as Mul<Saturating<isize>>>::Output

执行 * 操作。

impl Mul<&'_ Saturating<u128>> for Saturating<u128>

type Output = <Saturating<u128> as Mul<Saturating<u128>>>::Output

应用 * 运算符后的结果类型。

fn mul(
    self,
    other: &Saturating<u128>
) -> <Saturating<u128> as Mul<Saturating<u128>>>::Output

执行 * 操作。

impl Mul<&'_ Saturating<u128>> for &Saturating<u128>

type Output = <Saturating<u128> as Mul<Saturating<u128>>>::Output

应用 * 运算符后的结果类型。

fn mul(
    self,
    other: &Saturating<u128>
) -> <Saturating<u128> as Mul<Saturating<u128>>>::Output

执行 * 操作。

impl Mul<&'_ Saturating<u16>> for Saturating<u16>

type Output = <Saturating<u16> as Mul<Saturating<u16>>>::Output

应用 * 运算符后的结果类型。

fn mul(
    self,
    other: &Saturating<u16>
) -> <Saturating<u16> as Mul<Saturating<u16>>>::Output

执行 * 操作。

impl Mul<&'_ Saturating<u16>> for &Saturating<u16>

type Output = <Saturating<u16> as Mul<Saturating<u16>>>::Output

应用 * 运算符后的结果类型。

fn mul(
    self,
    other: &Saturating<u16>
) -> <Saturating<u16> as Mul<Saturating<u16>>>::Output

执行 * 操作。

impl Mul<&'_ Saturating<u32>> for Saturating<u32>

type Output = <Saturating<u32> as Mul<Saturating<u32>>>::Output

应用 * 运算符后的结果类型。

fn mul(
    self,
    other: &Saturating<u32>
) -> <Saturating<u32> as Mul<Saturating<u32>>>::Output

执行 * 操作。

impl Mul<&'_ Saturating<u32>> for &Saturating<u32>

type Output = <Saturating<u32> as Mul<Saturating<u32>>>::Output

应用 * 运算符后的结果类型。

fn mul(
    self,
    other: &Saturating<u32>
) -> <Saturating<u32> as Mul<Saturating<u32>>>::Output

执行 * 操作。

impl Mul<&'_ Saturating<u64>> for Saturating<u64>

type Output = <Saturating<u64> as Mul<Saturating<u64>>>::Output

应用 * 运算符后的结果类型。

fn mul(
    self,
    other: &Saturating<u64>
) -> <Saturating<u64> as Mul<Saturating<u64>>>::Output

执行 * 操作。

impl Mul<&'_ Saturating<u64>> for &Saturating<u64>

type Output = <Saturating<u64> as Mul<Saturating<u64>>>::Output

应用 * 运算符后的结果类型。

fn mul(
    self,
    other: &Saturating<u64>
) -> <Saturating<u64> as Mul<Saturating<u64>>>::Output

执行 * 操作。

impl Mul<&'_ Saturating<u8>> for Saturating<u8>

type Output = <Saturating<u8> as Mul<Saturating<u8>>>::Output

应用 * 运算符后的结果类型。

fn mul(
    self,
    other: &Saturating<u8>
) -> <Saturating<u8> as Mul<Saturating<u8>>>::Output

执行 * 操作。

impl Mul<&'_ Saturating<u8>> for &Saturating<u8>

type Output = <Saturating<u8> as Mul<Saturating<u8>>>::Output

应用 * 运算符后的结果类型。

fn mul(
    self,
    other: &Saturating<u8>
) -> <Saturating<u8> as Mul<Saturating<u8>>>::Output

执行 * 操作。

impl Mul<&'_ Saturating<usize>> for Saturating<usize>

type Output = <Saturating<usize> as Mul<Saturating<usize>>>::Output

应用 * 运算符后的结果类型。

fn mul(
    self,
    other: &Saturating<usize>
) -> <Saturating<usize> as Mul<Saturating<usize>>>::Output

执行 * 操作。

impl Mul<&'_ Saturating<usize>> for &Saturating<usize>

type Output = <Saturating<usize> as Mul<Saturating<usize>>>::Output

应用 * 运算符后的结果类型。

fn mul(
    self,
    other: &Saturating<usize>
) -> <Saturating<usize> as Mul<Saturating<usize>>>::Output

执行 * 操作。

impl Mul<Saturating<i128>> for Saturating<i128>

type Output = Saturating<i128>

应用 * 运算符后的结果类型。

fn mul(self, other: Saturating<i128>) -> Saturating<i128>

执行 * 操作。

impl<'a> Mul<Saturating<i128>> for &'a Saturating<i128>

type Output = <Saturating<i128> as Mul<Saturating<i128>>>::Output

应用 * 运算符后的结果类型。

fn mul(
    self,
    other: Saturating<i128>
) -> <Saturating<i128> as Mul<Saturating<i128>>>::Output

执行 * 操作。

impl Mul<Saturating<i16>> for Saturating<i16>

type Output = Saturating<i16>

应用 * 运算符后的结果类型。

fn mul(self, other: Saturating<i16>) -> Saturating<i16>

执行 * 操作。

impl<'a> Mul<Saturating<i16>> for &'a Saturating<i16>

type Output = <Saturating<i16> as Mul<Saturating<i16>>>::Output

应用 * 运算符后的结果类型。

fn mul(
    self,
    other: Saturating<i16>
) -> <Saturating<i16> as Mul<Saturating<i16>>>::Output

执行 * 操作。

impl Mul<Saturating<i32>> for Saturating<i32>

type Output = Saturating<i32>

应用 * 运算符后的结果类型。

fn mul(self, other: Saturating<i32>) -> Saturating<i32>

执行 * 操作。

impl<'a> Mul<Saturating<i32>> for &'a Saturating<i32>

type Output = <Saturating<i32> as Mul<Saturating<i32>>>::Output

应用 * 运算符后的结果类型。

fn mul(
    self,
    other: Saturating<i32>
) -> <Saturating<i32> as Mul<Saturating<i32>>>::Output

执行 * 操作。

impl Mul<Saturating<i64>> for Saturating<i64>

type Output = Saturating<i64>

应用 * 运算符后的结果类型。

fn mul(self, other: Saturating<i64>) -> Saturating<i64>

执行 * 操作。

impl<'a> Mul<Saturating<i64>> for &'a Saturating<i64>

type Output = <Saturating<i64> as Mul<Saturating<i64>>>::Output

应用 * 运算符后的结果类型。

fn mul(
    self,
    other: Saturating<i64>
) -> <Saturating<i64> as Mul<Saturating<i64>>>::Output

执行 * 操作。

impl Mul<Saturating<i8>> for Saturating<i8>

type Output = Saturating<i8>

应用 * 运算符后的结果类型。

fn mul(self, other: Saturating<i8>) -> Saturating<i8>

执行 * 操作。

impl<'a> Mul<Saturating<i8>> for &'a Saturating<i8>

type Output = <Saturating<i8> as Mul<Saturating<i8>>>::Output

应用 * 运算符后的结果类型。

fn mul(
    self,
    other: Saturating<i8>
) -> <Saturating<i8> as Mul<Saturating<i8>>>::Output

执行 * 操作。

impl Mul<Saturating<isize>> for Saturating<isize>

type Output = Saturating<isize>

应用 * 运算符后的结果类型。

fn mul(self, other: Saturating<isize>) -> Saturating<isize>

执行 * 操作。

impl<'a> Mul<Saturating<isize>> for &'a Saturating<isize>

type Output = <Saturating<isize> as Mul<Saturating<isize>>>::Output

应用 * 运算符后的结果类型。

fn mul(
    self,
    other: Saturating<isize>
) -> <Saturating<isize> as Mul<Saturating<isize>>>::Output

执行 * 操作。

impl Mul<Saturating<u128>> for Saturating<u128>

type Output = Saturating<u128>

应用 * 运算符后的结果类型。

fn mul(self, other: Saturating<u128>) -> Saturating<u128>

执行 * 操作。

impl<'a> Mul<Saturating<u128>> for &'a Saturating<u128>

type Output = <Saturating<u128> as Mul<Saturating<u128>>>::Output

应用 * 运算符后的结果类型。

fn mul(
    self,
    other: Saturating<u128>
) -> <Saturating<u128> as Mul<Saturating<u128>>>::Output

执行 * 操作。

impl Mul<Saturating<u16>> for Saturating<u16>

type Output = Saturating<u16>

应用 * 运算符后的结果类型。

fn mul(self, other: Saturating<u16>) -> Saturating<u16>

执行 * 操作。

impl<'a> Mul<Saturating<u16>> for &'a Saturating<u16>

type Output = <Saturating<u16> as Mul<Saturating<u16>>>::Output

应用 * 运算符后的结果类型。

fn mul(
    self,
    other: Saturating<u16>
) -> <Saturating<u16> as Mul<Saturating<u16>>>::Output

执行 * 操作。

impl Mul<Saturating<u32>> for Saturating<u32>

type Output = Saturating<u32>

应用 * 运算符后的结果类型。

fn mul(self, other: Saturating<u32>) -> Saturating<u32>

执行 * 操作。

impl<'a> Mul<Saturating<u32>> for &'a Saturating<u32>

type Output = <Saturating<u32> as Mul<Saturating<u32>>>::Output

应用 * 运算符后的结果类型。

fn mul(
    self,
    other: Saturating<u32>
) -> <Saturating<u32> as Mul<Saturating<u32>>>::Output

执行 * 操作。

impl Mul<Saturating<u64>> for Saturating<u64>

type Output = Saturating<u64>

应用 * 运算符后的结果类型。

fn mul(self, other: Saturating<u64>) -> Saturating<u64>

执行 * 操作。

impl<'a> Mul<Saturating<u64>> for &'a Saturating<u64>

type Output = <Saturating<u64> as Mul<Saturating<u64>>>::Output

应用 * 运算符后的结果类型。

fn mul(
    self,
    other: Saturating<u64>
) -> <Saturating<u64> as Mul<Saturating<u64>>>::Output

执行 * 操作。

impl Mul<Saturating<u8>> for Saturating<u8>

type Output = Saturating<u8>

应用 * 运算符后的结果类型。

fn mul(self, other: Saturating<u8>) -> Saturating<u8>

执行 * 操作。

impl<'a> Mul<Saturating<u8>> for &'a Saturating<u8>

type Output = <Saturating<u8> as Mul<Saturating<u8>>>::Output

应用 * 运算符后的结果类型。

fn mul(
    self,
    other: Saturating<u8>
) -> <Saturating<u8> as Mul<Saturating<u8>>>::Output

执行 * 操作。

impl Mul<Saturating<usize>> for Saturating<usize>

type Output = Saturating<usize>

应用 * 运算符后的结果类型。

fn mul(self, other: Saturating<usize>) -> Saturating<usize>

执行 * 操作。

impl<'a> Mul<Saturating<usize>> for &'a Saturating<usize>

type Output = <Saturating<usize> as Mul<Saturating<usize>>>::Output

应用 * 运算符后的结果类型。

fn mul(
    self,
    other: Saturating<usize>
) -> <Saturating<usize> as Mul<Saturating<usize>>>::Output

执行 * 操作。

impl MulAssign<&'_ Saturating<i128>> for Saturating<i128>

fn mul_assign(&mut self, other: &Saturating<i128>)

执行 *= 操作。

impl MulAssign<&'_ Saturating<i16>> for Saturating<i16>

fn mul_assign(&mut self, other: &Saturating<i16>)

执行 *= 操作。

impl MulAssign<&'_ Saturating<i32>> for Saturating<i32>

fn mul_assign(&mut self, other: &Saturating<i32>)

执行 *= 操作。

impl MulAssign<&'_ Saturating<i64>> for Saturating<i64>

fn mul_assign(&mut self, other: &Saturating<i64>)

执行 *= 操作。

impl MulAssign<&'_ Saturating<i8>> for Saturating<i8>

fn mul_assign(&mut self, other: &Saturating<i8>)

执行 *= 操作。

impl MulAssign<&'_ Saturating<isize>> for Saturating<isize>

fn mul_assign(&mut self, other: &Saturating<isize>)

执行 *= 操作。

impl MulAssign<&'_ Saturating<u128>> for Saturating<u128>

fn mul_assign(&mut self, other: &Saturating<u128>)

执行 *= 操作。

impl MulAssign<&'_ Saturating<u16>> for Saturating<u16>

fn mul_assign(&mut self, other: &Saturating<u16>)

执行 *= 操作。

impl MulAssign<&'_ Saturating<u32>> for Saturating<u32>

fn mul_assign(&mut self, other: &Saturating<u32>)

执行 *= 操作。

impl MulAssign<&'_ Saturating<u64>> for Saturating<u64>

fn mul_assign(&mut self, other: &Saturating<u64>)

执行 *= 操作。

impl MulAssign<&'_ Saturating<u8>> for Saturating<u8>

fn mul_assign(&mut self, other: &Saturating<u8>)

执行 *= 操作。

impl MulAssign<&'_ Saturating<usize>> for Saturating<usize>

fn mul_assign(&mut self, other: &Saturating<usize>)

执行 *= 操作。

impl MulAssign<Saturating<i128>> for Saturating<i128>

fn mul_assign(&mut self, other: Saturating<i128>)

执行 *= 操作。

impl MulAssign<Saturating<i16>> for Saturating<i16>

fn mul_assign(&mut self, other: Saturating<i16>)

执行 *= 操作。

impl MulAssign<Saturating<i32>> for Saturating<i32>

fn mul_assign(&mut self, other: Saturating<i32>)

执行 *= 操作。

impl MulAssign<Saturating<i64>> for Saturating<i64>

fn mul_assign(&mut self, other: Saturating<i64>)

执行 *= 操作。

impl MulAssign<Saturating<i8>> for Saturating<i8>

fn mul_assign(&mut self, other: Saturating<i8>)

执行 *= 操作。

impl MulAssign<Saturating<isize>> for Saturating<isize>

fn mul_assign(&mut self, other: Saturating<isize>)

执行 *= 操作。

impl MulAssign<Saturating<u128>> for Saturating<u128>

fn mul_assign(&mut self, other: Saturating<u128>)

执行 *= 操作。

impl MulAssign<Saturating<u16>> for Saturating<u16>

fn mul_assign(&mut self, other: Saturating<u16>)

执行 *= 操作。

impl MulAssign<Saturating<u32>> for Saturating<u32>

fn mul_assign(&mut self, other: Saturating<u32>)

执行 *= 操作。

impl MulAssign<Saturating<u64>> for Saturating<u64>

fn mul_assign(&mut self, other: Saturating<u64>)

执行 *= 操作。

impl MulAssign<Saturating<u8>> for Saturating<u8>

fn mul_assign(&mut self, other: Saturating<u8>)

执行 *= 操作。

impl MulAssign<Saturating<usize>> for Saturating<usize>

fn mul_assign(&mut self, other: Saturating<usize>)

执行 *= 操作。

impl Neg for Saturating<isize>

type Output = Self

应用 - 运算符后的结果类型。

fn neg(self) -> Self

执行一元 - 运算。

impl Neg for &Saturating<isize>

type Output = <Saturating<isize> as Neg>::Output

应用 - 运算符后的结果类型。

fn neg(self) -> <Saturating<isize> as Neg>::Output

执行一元 - 运算。

impl Neg for Saturating<i128>

type Output = Self

应用 - 运算符后的结果类型。

fn neg(self) -> Self

执行一元 - 运算。

impl Neg for &Saturating<i128>

type Output = <Saturating<i128> as Neg>::Output

应用 - 运算符后的结果类型。

fn neg(self) -> <Saturating<i128> as Neg>::Output

执行一元 - 运算。

impl Neg for Saturating<i8>

type Output = Self

应用 - 运算符后的结果类型。

fn neg(self) -> Self

执行一元 - 运算。

impl Neg for &Saturating<i8>

type Output = <Saturating<i8> as Neg>::Output

应用 - 运算符后的结果类型。

fn neg(self) -> <Saturating<i8> as Neg>::Output

执行一元 - 运算。

impl Neg for Saturating<i16>

type Output = Self

应用 - 运算符后的结果类型。

fn neg(self) -> Self

执行一元 - 运算。

impl Neg for &Saturating<i16>

type Output = <Saturating<i16> as Neg>::Output

应用 - 运算符后的结果类型。

fn neg(self) -> <Saturating<i16> as Neg>::Output

执行一元 - 运算。

impl Neg for Saturating<i32>

type Output = Self

应用 - 运算符后的结果类型。

fn neg(self) -> Self

执行一元 - 运算。

impl Neg for &Saturating<i32>

type Output = <Saturating<i32> as Neg>::Output

应用 - 运算符后的结果类型。

fn neg(self) -> <Saturating<i32> as Neg>::Output

执行一元 - 运算。

impl Neg for Saturating<i64>

type Output = Self

应用 - 运算符后的结果类型。

fn neg(self) -> Self

执行一元 - 运算。

impl Neg for &Saturating<i64>

type Output = <Saturating<i64> as Neg>::Output

应用 - 运算符后的结果类型。

fn neg(self) -> <Saturating<i64> as Neg>::Output

执行一元 - 运算。

impl Not for Saturating<usize>

type Output = Saturating<usize>

应用 ! 运算符后的结果类型。

fn not(self) -> Saturating<usize>

执行一元 ! 操作。

impl Not for &Saturating<usize>

type Output = <Saturating<usize> as Not>::Output

应用 ! 运算符后的结果类型。

fn not(self) -> <Saturating<usize> as Not>::Output

执行一元 ! 操作。

impl Not for Saturating<u128>

type Output = Saturating<u128>

应用 ! 运算符后的结果类型。

fn not(self) -> Saturating<u128>

执行一元 ! 操作。

impl Not for &Saturating<u128>

type Output = <Saturating<u128> as Not>::Output

应用 ! 运算符后的结果类型。

fn not(self) -> <Saturating<u128> as Not>::Output

执行一元 ! 操作。

impl Not for Saturating<isize>

type Output = Saturating<isize>

应用 ! 运算符后的结果类型。

fn not(self) -> Saturating<isize>

执行一元 ! 操作。

impl Not for &Saturating<isize>

type Output = <Saturating<isize> as Not>::Output

应用 ! 运算符后的结果类型。

fn not(self) -> <Saturating<isize> as Not>::Output

执行一元 ! 操作。

impl Not for Saturating<i8>

type Output = Saturating<i8>

应用 ! 运算符后的结果类型。

fn not(self) -> Saturating<i8>

执行一元 ! 操作。

impl Not for &Saturating<i8>

type Output = <Saturating<i8> as Not>::Output

应用 ! 运算符后的结果类型。

fn not(self) -> <Saturating<i8> as Not>::Output

执行一元 ! 操作。

impl Not for Saturating<i16>

type Output = Saturating<i16>

应用 ! 运算符后的结果类型。

fn not(self) -> Saturating<i16>

执行一元 ! 操作。

impl Not for &Saturating<i16>

type Output = <Saturating<i16> as Not>::Output

应用 ! 运算符后的结果类型。

fn not(self) -> <Saturating<i16> as Not>::Output

执行一元 ! 操作。

impl Not for Saturating<i32>

type Output = Saturating<i32>

应用 ! 运算符后的结果类型。

fn not(self) -> Saturating<i32>

执行一元 ! 操作。

impl Not for &Saturating<i32>

type Output = <Saturating<i32> as Not>::Output

应用 ! 运算符后的结果类型。

fn not(self) -> <Saturating<i32> as Not>::Output

执行一元 ! 操作。

impl Not for Saturating<u8>

type Output = Saturating<u8>

应用 ! 运算符后的结果类型。

fn not(self) -> Saturating<u8>

执行一元 ! 操作。

impl Not for Saturating<i64>

type Output = Saturating<i64>

应用 ! 运算符后的结果类型。

fn not(self) -> Saturating<i64>

执行一元 ! 操作。

impl Not for &Saturating<i64>

type Output = <Saturating<i64> as Not>::Output

应用 ! 运算符后的结果类型。

fn not(self) -> <Saturating<i64> as Not>::Output

执行一元 ! 操作。

impl Not for Saturating<i128>

type Output = Saturating<i128>

应用 ! 运算符后的结果类型。

fn not(self) -> Saturating<i128>

执行一元 ! 操作。

impl Not for &Saturating<i128>

type Output = <Saturating<i128> as Not>::Output

应用 ! 运算符后的结果类型。

fn not(self) -> <Saturating<i128> as Not>::Output

执行一元 ! 操作。

impl Not for &Saturating<u8>

type Output = <Saturating<u8> as Not>::Output

应用 ! 运算符后的结果类型。

fn not(self) -> <Saturating<u8> as Not>::Output

执行一元 ! 操作。

impl Not for Saturating<u16>

type Output = Saturating<u16>

应用 ! 运算符后的结果类型。

fn not(self) -> Saturating<u16>

执行一元 ! 操作。

impl Not for &Saturating<u16>

type Output = <Saturating<u16> as Not>::Output

应用 ! 运算符后的结果类型。

fn not(self) -> <Saturating<u16> as Not>::Output

执行一元 ! 操作。

impl Not for Saturating<u32>

type Output = Saturating<u32>

应用 ! 运算符后的结果类型。

fn not(self) -> Saturating<u32>

执行一元 ! 操作。

impl Not for &Saturating<u32>

type Output = <Saturating<u32> as Not>::Output

应用 ! 运算符后的结果类型。

fn not(self) -> <Saturating<u32> as Not>::Output

执行一元 ! 操作。

impl Not for Saturating<u64>

type Output = Saturating<u64>

应用 ! 运算符后的结果类型。

fn not(self) -> Saturating<u64>

执行一元 ! 操作。

impl Not for &Saturating<u64>

type Output = <Saturating<u64> as Not>::Output

应用 ! 运算符后的结果类型。

fn not(self) -> <Saturating<u64> as Not>::Output

执行一元 ! 操作。

impl<T: Octal> Octal for Saturating<T>

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

使用给定的格式化程序格式化该值。

impl<T: Ord> Ord for Saturating<T>

fn cmp(&self, other: &Saturating<T>) -> Ordering

此方法返回 self 和 other 之间的 Ordering。

fn max(self, other: Self) -> Self where
    Self: Sized, 

比较并返回两个值中的最大值。

fn min(self, other: Self) -> Self where
    Self: Sized, 

比较并返回两个值中的最小值。

fn clamp(self, min: Self, max: Self) -> Self where
    Self: Sized, 

将值限制在某个时间间隔内。

impl<T: PartialEq> PartialEq<Saturating<T>> for Saturating<T>

fn eq(&self, other: &Saturating<T>) -> bool

此方法测试 self 和 other 值是否相等，并由 == 使用。

fn ne(&self, other: &Saturating<T>) -> bool

此方法测试 !=。

impl<T: PartialOrd> PartialOrd<Saturating<T>> for Saturating<T>

fn partial_cmp(&self, other: &Saturating<T>) -> Option<Ordering>

如果存在，则此方法返回 self 和 other 值之间的顺序。

fn lt(&self, other: &Rhs) -> bool

此方法测试的内容少于 (对于 self 和 other)，并且由 < 操作员使用。

fn le(&self, other: &Rhs) -> bool

此方法测试小于或等于 (对于 self 和 other)，并且由 <= 运算符使用。

fn gt(&self, other: &Rhs) -> bool

此方法测试大于 (对于 self 和 other)，并且由 > 操作员使用。

fn ge(&self, other: &Rhs) -> bool

此方法测试是否大于或等于 (对于 self 和 other)，并且由 >= 运算符使用。

impl Rem<&'_ Saturating<i128>> for Saturating<i128>

type Output = <Saturating<i128> as Rem<Saturating<i128>>>::Output

应用 % 运算符后的结果类型。

fn rem(
    self,
    other: &Saturating<i128>
) -> <Saturating<i128> as Rem<Saturating<i128>>>::Output

执行 % 操作。

impl Rem<&'_ Saturating<i128>> for &Saturating<i128>

type Output = <Saturating<i128> as Rem<Saturating<i128>>>::Output

应用 % 运算符后的结果类型。

fn rem(
    self,
    other: &Saturating<i128>
) -> <Saturating<i128> as Rem<Saturating<i128>>>::Output

执行 % 操作。

impl Rem<&'_ Saturating<i16>> for Saturating<i16>

type Output = <Saturating<i16> as Rem<Saturating<i16>>>::Output

应用 % 运算符后的结果类型。

fn rem(
    self,
    other: &Saturating<i16>
) -> <Saturating<i16> as Rem<Saturating<i16>>>::Output

执行 % 操作。

impl Rem<&'_ Saturating<i16>> for &Saturating<i16>

type Output = <Saturating<i16> as Rem<Saturating<i16>>>::Output

应用 % 运算符后的结果类型。

fn rem(
    self,
    other: &Saturating<i16>
) -> <Saturating<i16> as Rem<Saturating<i16>>>::Output

执行 % 操作。

impl Rem<&'_ Saturating<i32>> for Saturating<i32>

type Output = <Saturating<i32> as Rem<Saturating<i32>>>::Output

应用 % 运算符后的结果类型。

fn rem(
    self,
    other: &Saturating<i32>
) -> <Saturating<i32> as Rem<Saturating<i32>>>::Output

执行 % 操作。

impl Rem<&'_ Saturating<i32>> for &Saturating<i32>

type Output = <Saturating<i32> as Rem<Saturating<i32>>>::Output

应用 % 运算符后的结果类型。

fn rem(
    self,
    other: &Saturating<i32>
) -> <Saturating<i32> as Rem<Saturating<i32>>>::Output

执行 % 操作。

impl Rem<&'_ Saturating<i64>> for Saturating<i64>

type Output = <Saturating<i64> as Rem<Saturating<i64>>>::Output

应用 % 运算符后的结果类型。

fn rem(
    self,
    other: &Saturating<i64>
) -> <Saturating<i64> as Rem<Saturating<i64>>>::Output

执行 % 操作。

impl Rem<&'_ Saturating<i64>> for &Saturating<i64>

type Output = <Saturating<i64> as Rem<Saturating<i64>>>::Output

应用 % 运算符后的结果类型。

fn rem(
    self,
    other: &Saturating<i64>
) -> <Saturating<i64> as Rem<Saturating<i64>>>::Output

执行 % 操作。

impl Rem<&'_ Saturating<i8>> for Saturating<i8>

type Output = <Saturating<i8> as Rem<Saturating<i8>>>::Output

应用 % 运算符后的结果类型。

fn rem(
    self,
    other: &Saturating<i8>
) -> <Saturating<i8> as Rem<Saturating<i8>>>::Output

执行 % 操作。

impl Rem<&'_ Saturating<i8>> for &Saturating<i8>

type Output = <Saturating<i8> as Rem<Saturating<i8>>>::Output

应用 % 运算符后的结果类型。

fn rem(
    self,
    other: &Saturating<i8>
) -> <Saturating<i8> as Rem<Saturating<i8>>>::Output

执行 % 操作。

impl Rem<&'_ Saturating<isize>> for Saturating<isize>

type Output = <Saturating<isize> as Rem<Saturating<isize>>>::Output

应用 % 运算符后的结果类型。

fn rem(
    self,
    other: &Saturating<isize>
) -> <Saturating<isize> as Rem<Saturating<isize>>>::Output

执行 % 操作。

impl Rem<&'_ Saturating<isize>> for &Saturating<isize>

type Output = <Saturating<isize> as Rem<Saturating<isize>>>::Output

应用 % 运算符后的结果类型。

fn rem(
    self,
    other: &Saturating<isize>
) -> <Saturating<isize> as Rem<Saturating<isize>>>::Output

执行 % 操作。

impl Rem<&'_ Saturating<u128>> for Saturating<u128>

type Output = <Saturating<u128> as Rem<Saturating<u128>>>::Output

应用 % 运算符后的结果类型。

fn rem(
    self,
    other: &Saturating<u128>
) -> <Saturating<u128> as Rem<Saturating<u128>>>::Output

执行 % 操作。

impl Rem<&'_ Saturating<u128>> for &Saturating<u128>

type Output = <Saturating<u128> as Rem<Saturating<u128>>>::Output

应用 % 运算符后的结果类型。

fn rem(
    self,
    other: &Saturating<u128>
) -> <Saturating<u128> as Rem<Saturating<u128>>>::Output

执行 % 操作。

impl Rem<&'_ Saturating<u16>> for Saturating<u16>

type Output = <Saturating<u16> as Rem<Saturating<u16>>>::Output

应用 % 运算符后的结果类型。

fn rem(
    self,
    other: &Saturating<u16>
) -> <Saturating<u16> as Rem<Saturating<u16>>>::Output

执行 % 操作。

impl Rem<&'_ Saturating<u16>> for &Saturating<u16>

type Output = <Saturating<u16> as Rem<Saturating<u16>>>::Output

应用 % 运算符后的结果类型。

fn rem(
    self,
    other: &Saturating<u16>
) -> <Saturating<u16> as Rem<Saturating<u16>>>::Output

执行 % 操作。

impl Rem<&'_ Saturating<u32>> for Saturating<u32>

type Output = <Saturating<u32> as Rem<Saturating<u32>>>::Output

应用 % 运算符后的结果类型。

fn rem(
    self,
    other: &Saturating<u32>
) -> <Saturating<u32> as Rem<Saturating<u32>>>::Output

执行 % 操作。

impl Rem<&'_ Saturating<u32>> for &Saturating<u32>

type Output = <Saturating<u32> as Rem<Saturating<u32>>>::Output

应用 % 运算符后的结果类型。

fn rem(
    self,
    other: &Saturating<u32>
) -> <Saturating<u32> as Rem<Saturating<u32>>>::Output

执行 % 操作。

impl Rem<&'_ Saturating<u64>> for Saturating<u64>

type Output = <Saturating<u64> as Rem<Saturating<u64>>>::Output

应用 % 运算符后的结果类型。

fn rem(
    self,
    other: &Saturating<u64>
) -> <Saturating<u64> as Rem<Saturating<u64>>>::Output

执行 % 操作。

impl Rem<&'_ Saturating<u64>> for &Saturating<u64>

type Output = <Saturating<u64> as Rem<Saturating<u64>>>::Output

应用 % 运算符后的结果类型。

fn rem(
    self,
    other: &Saturating<u64>
) -> <Saturating<u64> as Rem<Saturating<u64>>>::Output

执行 % 操作。

impl Rem<&'_ Saturating<u8>> for Saturating<u8>

type Output = <Saturating<u8> as Rem<Saturating<u8>>>::Output

应用 % 运算符后的结果类型。

fn rem(
    self,
    other: &Saturating<u8>
) -> <Saturating<u8> as Rem<Saturating<u8>>>::Output

执行 % 操作。

impl Rem<&'_ Saturating<u8>> for &Saturating<u8>

type Output = <Saturating<u8> as Rem<Saturating<u8>>>::Output

应用 % 运算符后的结果类型。

fn rem(
    self,
    other: &Saturating<u8>
) -> <Saturating<u8> as Rem<Saturating<u8>>>::Output

执行 % 操作。

impl Rem<&'_ Saturating<usize>> for Saturating<usize>

type Output = <Saturating<usize> as Rem<Saturating<usize>>>::Output

应用 % 运算符后的结果类型。

fn rem(
    self,
    other: &Saturating<usize>
) -> <Saturating<usize> as Rem<Saturating<usize>>>::Output

执行 % 操作。

impl Rem<&'_ Saturating<usize>> for &Saturating<usize>

type Output = <Saturating<usize> as Rem<Saturating<usize>>>::Output

应用 % 运算符后的结果类型。

fn rem(
    self,
    other: &Saturating<usize>
) -> <Saturating<usize> as Rem<Saturating<usize>>>::Output

执行 % 操作。

impl Rem<Saturating<i128>> for Saturating<i128>

type Output = Saturating<i128>

应用 % 运算符后的结果类型。

fn rem(self, other: Saturating<i128>) -> Saturating<i128>

执行 % 操作。

impl<'a> Rem<Saturating<i128>> for &'a Saturating<i128>

type Output = <Saturating<i128> as Rem<Saturating<i128>>>::Output

应用 % 运算符后的结果类型。

fn rem(
    self,
    other: Saturating<i128>
) -> <Saturating<i128> as Rem<Saturating<i128>>>::Output

执行 % 操作。

impl Rem<Saturating<i16>> for Saturating<i16>

type Output = Saturating<i16>

应用 % 运算符后的结果类型。

fn rem(self, other: Saturating<i16>) -> Saturating<i16>

执行 % 操作。

impl<'a> Rem<Saturating<i16>> for &'a Saturating<i16>

type Output = <Saturating<i16> as Rem<Saturating<i16>>>::Output

应用 % 运算符后的结果类型。

fn rem(
    self,
    other: Saturating<i16>
) -> <Saturating<i16> as Rem<Saturating<i16>>>::Output

执行 % 操作。

impl Rem<Saturating<i32>> for Saturating<i32>

type Output = Saturating<i32>

应用 % 运算符后的结果类型。

fn rem(self, other: Saturating<i32>) -> Saturating<i32>

执行 % 操作。

impl<'a> Rem<Saturating<i32>> for &'a Saturating<i32>

type Output = <Saturating<i32> as Rem<Saturating<i32>>>::Output

应用 % 运算符后的结果类型。

fn rem(
    self,
    other: Saturating<i32>
) -> <Saturating<i32> as Rem<Saturating<i32>>>::Output

执行 % 操作。

impl Rem<Saturating<i64>> for Saturating<i64>

type Output = Saturating<i64>

应用 % 运算符后的结果类型。

fn rem(self, other: Saturating<i64>) -> Saturating<i64>

执行 % 操作。

impl<'a> Rem<Saturating<i64>> for &'a Saturating<i64>

type Output = <Saturating<i64> as Rem<Saturating<i64>>>::Output

应用 % 运算符后的结果类型。

fn rem(
    self,
    other: Saturating<i64>
) -> <Saturating<i64> as Rem<Saturating<i64>>>::Output

执行 % 操作。

impl Rem<Saturating<i8>> for Saturating<i8>

type Output = Saturating<i8>

应用 % 运算符后的结果类型。

fn rem(self, other: Saturating<i8>) -> Saturating<i8>

执行 % 操作。

impl<'a> Rem<Saturating<i8>> for &'a Saturating<i8>

type Output = <Saturating<i8> as Rem<Saturating<i8>>>::Output

应用 % 运算符后的结果类型。

fn rem(
    self,
    other: Saturating<i8>
) -> <Saturating<i8> as Rem<Saturating<i8>>>::Output

执行 % 操作。

impl Rem<Saturating<isize>> for Saturating<isize>

type Output = Saturating<isize>

应用 % 运算符后的结果类型。

fn rem(self, other: Saturating<isize>) -> Saturating<isize>

执行 % 操作。

impl<'a> Rem<Saturating<isize>> for &'a Saturating<isize>

type Output = <Saturating<isize> as Rem<Saturating<isize>>>::Output

应用 % 运算符后的结果类型。

fn rem(
    self,
    other: Saturating<isize>
) -> <Saturating<isize> as Rem<Saturating<isize>>>::Output

执行 % 操作。

impl Rem<Saturating<u128>> for Saturating<u128>

type Output = Saturating<u128>

应用 % 运算符后的结果类型。

fn rem(self, other: Saturating<u128>) -> Saturating<u128>

执行 % 操作。

impl<'a> Rem<Saturating<u128>> for &'a Saturating<u128>

type Output = <Saturating<u128> as Rem<Saturating<u128>>>::Output

应用 % 运算符后的结果类型。

fn rem(
    self,
    other: Saturating<u128>
) -> <Saturating<u128> as Rem<Saturating<u128>>>::Output

执行 % 操作。

impl Rem<Saturating<u16>> for Saturating<u16>

type Output = Saturating<u16>

应用 % 运算符后的结果类型。

fn rem(self, other: Saturating<u16>) -> Saturating<u16>

执行 % 操作。

impl<'a> Rem<Saturating<u16>> for &'a Saturating<u16>

type Output = <Saturating<u16> as Rem<Saturating<u16>>>::Output

应用 % 运算符后的结果类型。

fn rem(
    self,
    other: Saturating<u16>
) -> <Saturating<u16> as Rem<Saturating<u16>>>::Output

执行 % 操作。

impl Rem<Saturating<u32>> for Saturating<u32>

type Output = Saturating<u32>

应用 % 运算符后的结果类型。

fn rem(self, other: Saturating<u32>) -> Saturating<u32>

执行 % 操作。

impl<'a> Rem<Saturating<u32>> for &'a Saturating<u32>

type Output = <Saturating<u32> as Rem<Saturating<u32>>>::Output

应用 % 运算符后的结果类型。

fn rem(
    self,
    other: Saturating<u32>
) -> <Saturating<u32> as Rem<Saturating<u32>>>::Output

执行 % 操作。

impl Rem<Saturating<u64>> for Saturating<u64>

type Output = Saturating<u64>

应用 % 运算符后的结果类型。

fn rem(self, other: Saturating<u64>) -> Saturating<u64>

执行 % 操作。

impl<'a> Rem<Saturating<u64>> for &'a Saturating<u64>

type Output = <Saturating<u64> as Rem<Saturating<u64>>>::Output

应用 % 运算符后的结果类型。

fn rem(
    self,
    other: Saturating<u64>
) -> <Saturating<u64> as Rem<Saturating<u64>>>::Output

执行 % 操作。

impl Rem<Saturating<u8>> for Saturating<u8>

type Output = Saturating<u8>

应用 % 运算符后的结果类型。

fn rem(self, other: Saturating<u8>) -> Saturating<u8>

执行 % 操作。

impl<'a> Rem<Saturating<u8>> for &'a Saturating<u8>

type Output = <Saturating<u8> as Rem<Saturating<u8>>>::Output

应用 % 运算符后的结果类型。

fn rem(
    self,
    other: Saturating<u8>
) -> <Saturating<u8> as Rem<Saturating<u8>>>::Output

执行 % 操作。

impl Rem<Saturating<usize>> for Saturating<usize>

type Output = Saturating<usize>

应用 % 运算符后的结果类型。

fn rem(self, other: Saturating<usize>) -> Saturating<usize>

执行 % 操作。

impl<'a> Rem<Saturating<usize>> for &'a Saturating<usize>

type Output = <Saturating<usize> as Rem<Saturating<usize>>>::Output

应用 % 运算符后的结果类型。

fn rem(
    self,
    other: Saturating<usize>
) -> <Saturating<usize> as Rem<Saturating<usize>>>::Output

执行 % 操作。

impl RemAssign<&'_ Saturating<i128>> for Saturating<i128>

fn rem_assign(&mut self, other: &Saturating<i128>)

执行 %= 操作。

impl RemAssign<&'_ Saturating<i16>> for Saturating<i16>

fn rem_assign(&mut self, other: &Saturating<i16>)

执行 %= 操作。

impl RemAssign<&'_ Saturating<i32>> for Saturating<i32>

fn rem_assign(&mut self, other: &Saturating<i32>)

执行 %= 操作。

impl RemAssign<&'_ Saturating<i64>> for Saturating<i64>

fn rem_assign(&mut self, other: &Saturating<i64>)

执行 %= 操作。

impl RemAssign<&'_ Saturating<i8>> for Saturating<i8>

fn rem_assign(&mut self, other: &Saturating<i8>)

执行 %= 操作。

impl RemAssign<&'_ Saturating<isize>> for Saturating<isize>

fn rem_assign(&mut self, other: &Saturating<isize>)

执行 %= 操作。

impl RemAssign<&'_ Saturating<u128>> for Saturating<u128>

fn rem_assign(&mut self, other: &Saturating<u128>)

执行 %= 操作。

impl RemAssign<&'_ Saturating<u16>> for Saturating<u16>

fn rem_assign(&mut self, other: &Saturating<u16>)

执行 %= 操作。

impl RemAssign<&'_ Saturating<u32>> for Saturating<u32>

fn rem_assign(&mut self, other: &Saturating<u32>)

执行 %= 操作。

impl RemAssign<&'_ Saturating<u64>> for Saturating<u64>

fn rem_assign(&mut self, other: &Saturating<u64>)

执行 %= 操作。

impl RemAssign<&'_ Saturating<u8>> for Saturating<u8>

fn rem_assign(&mut self, other: &Saturating<u8>)

执行 %= 操作。

impl RemAssign<&'_ Saturating<usize>> for Saturating<usize>

fn rem_assign(&mut self, other: &Saturating<usize>)

执行 %= 操作。

impl RemAssign<Saturating<i128>> for Saturating<i128>

fn rem_assign(&mut self, other: Saturating<i128>)

执行 %= 操作。

impl RemAssign<Saturating<i16>> for Saturating<i16>

fn rem_assign(&mut self, other: Saturating<i16>)

执行 %= 操作。

impl RemAssign<Saturating<i32>> for Saturating<i32>

fn rem_assign(&mut self, other: Saturating<i32>)

执行 %= 操作。

impl RemAssign<Saturating<i64>> for Saturating<i64>

fn rem_assign(&mut self, other: Saturating<i64>)

执行 %= 操作。

impl RemAssign<Saturating<i8>> for Saturating<i8>

fn rem_assign(&mut self, other: Saturating<i8>)

执行 %= 操作。

impl RemAssign<Saturating<isize>> for Saturating<isize>

fn rem_assign(&mut self, other: Saturating<isize>)

执行 %= 操作。

impl RemAssign<Saturating<u128>> for Saturating<u128>

fn rem_assign(&mut self, other: Saturating<u128>)

执行 %= 操作。

impl RemAssign<Saturating<u16>> for Saturating<u16>

fn rem_assign(&mut self, other: Saturating<u16>)

执行 %= 操作。

impl RemAssign<Saturating<u32>> for Saturating<u32>

fn rem_assign(&mut self, other: Saturating<u32>)

执行 %= 操作。

impl RemAssign<Saturating<u64>> for Saturating<u64>

fn rem_assign(&mut self, other: Saturating<u64>)

执行 %= 操作。

impl RemAssign<Saturating<u8>> for Saturating<u8>

fn rem_assign(&mut self, other: Saturating<u8>)

执行 %= 操作。

impl RemAssign<Saturating<usize>> for Saturating<usize>

fn rem_assign(&mut self, other: Saturating<usize>)

执行 %= 操作。

impl Shl<&'_ usize> for Saturating<u8>

type Output = <Saturating<u8> as Shl<usize>>::Output

应用 << 运算符后的结果类型。

fn shl(self, other: &usize) -> <Saturating<u8> as Shl<usize>>::Output

执行 << 操作。

impl Shl<&'_ usize> for &Saturating<u8>

type Output = <Saturating<u8> as Shl<usize>>::Output

应用 << 运算符后的结果类型。

fn shl(self, other: &usize) -> <Saturating<u8> as Shl<usize>>::Output

执行 << 操作。

impl Shl<&'_ usize> for Saturating<usize>

type Output = <Saturating<usize> as Shl<usize>>::Output

应用 << 运算符后的结果类型。

fn shl(self, other: &usize) -> <Saturating<usize> as Shl<usize>>::Output

执行 << 操作。

impl Shl<&'_ usize> for &Saturating<usize>

type Output = <Saturating<usize> as Shl<usize>>::Output

应用 << 运算符后的结果类型。

fn shl(self, other: &usize) -> <Saturating<usize> as Shl<usize>>::Output

执行 << 操作。

impl Shl<&'_ usize> for Saturating<i8>

type Output = <Saturating<i8> as Shl<usize>>::Output

应用 << 运算符后的结果类型。

fn shl(self, other: &usize) -> <Saturating<i8> as Shl<usize>>::Output

执行 << 操作。

impl Shl<&'_ usize> for &Saturating<i8>

type Output = <Saturating<i8> as Shl<usize>>::Output

应用 << 运算符后的结果类型。

fn shl(self, other: &usize) -> <Saturating<i8> as Shl<usize>>::Output

执行 << 操作。

impl Shl<&'_ usize> for Saturating<i16>

type Output = <Saturating<i16> as Shl<usize>>::Output

应用 << 运算符后的结果类型。

fn shl(self, other: &usize) -> <Saturating<i16> as Shl<usize>>::Output

执行 << 操作。

impl Shl<&'_ usize> for &Saturating<i16>

type Output = <Saturating<i16> as Shl<usize>>::Output

应用 << 运算符后的结果类型。

fn shl(self, other: &usize) -> <Saturating<i16> as Shl<usize>>::Output

执行 << 操作。

impl Shl<&'_ usize> for Saturating<i32>

type Output = <Saturating<i32> as Shl<usize>>::Output

应用 << 运算符后的结果类型。

fn shl(self, other: &usize) -> <Saturating<i32> as Shl<usize>>::Output

执行 << 操作。

impl Shl<&'_ usize> for &Saturating<i32>

type Output = <Saturating<i32> as Shl<usize>>::Output

应用 << 运算符后的结果类型。

fn shl(self, other: &usize) -> <Saturating<i32> as Shl<usize>>::Output

执行 << 操作。

impl Shl<&'_ usize> for Saturating<i64>

type Output = <Saturating<i64> as Shl<usize>>::Output

应用 << 运算符后的结果类型。

fn shl(self, other: &usize) -> <Saturating<i64> as Shl<usize>>::Output

执行 << 操作。

impl Shl<&'_ usize> for &Saturating<i64>

type Output = <Saturating<i64> as Shl<usize>>::Output

应用 << 运算符后的结果类型。

fn shl(self, other: &usize) -> <Saturating<i64> as Shl<usize>>::Output

执行 << 操作。

impl Shl<&'_ usize> for Saturating<u16>

type Output = <Saturating<u16> as Shl<usize>>::Output

应用 << 运算符后的结果类型。

fn shl(self, other: &usize) -> <Saturating<u16> as Shl<usize>>::Output

执行 << 操作。

impl Shl<&'_ usize> for Saturating<i128>

type Output = <Saturating<i128> as Shl<usize>>::Output

应用 << 运算符后的结果类型。

fn shl(self, other: &usize) -> <Saturating<i128> as Shl<usize>>::Output

执行 << 操作。

impl Shl<&'_ usize> for &Saturating<i128>

type Output = <Saturating<i128> as Shl<usize>>::Output

应用 << 运算符后的结果类型。

fn shl(self, other: &usize) -> <Saturating<i128> as Shl<usize>>::Output

执行 << 操作。

impl Shl<&'_ usize> for Saturating<isize>

type Output = <Saturating<isize> as Shl<usize>>::Output

应用 << 运算符后的结果类型。

fn shl(self, other: &usize) -> <Saturating<isize> as Shl<usize>>::Output

执行 << 操作。

impl Shl<&'_ usize> for &Saturating<isize>

type Output = <Saturating<isize> as Shl<usize>>::Output

应用 << 运算符后的结果类型。

fn shl(self, other: &usize) -> <Saturating<isize> as Shl<usize>>::Output

执行 << 操作。

impl Shl<&'_ usize> for &Saturating<u16>

type Output = <Saturating<u16> as Shl<usize>>::Output

应用 << 运算符后的结果类型。

fn shl(self, other: &usize) -> <Saturating<u16> as Shl<usize>>::Output

执行 << 操作。

impl Shl<&'_ usize> for Saturating<u32>

type Output = <Saturating<u32> as Shl<usize>>::Output

应用 << 运算符后的结果类型。

fn shl(self, other: &usize) -> <Saturating<u32> as Shl<usize>>::Output

执行 << 操作。

impl Shl<&'_ usize> for &Saturating<u32>

type Output = <Saturating<u32> as Shl<usize>>::Output

应用 << 运算符后的结果类型。

fn shl(self, other: &usize) -> <Saturating<u32> as Shl<usize>>::Output

执行 << 操作。

impl Shl<&'_ usize> for Saturating<u64>

type Output = <Saturating<u64> as Shl<usize>>::Output

应用 << 运算符后的结果类型。

fn shl(self, other: &usize) -> <Saturating<u64> as Shl<usize>>::Output

执行 << 操作。

impl Shl<&'_ usize> for &Saturating<u64>

type Output = <Saturating<u64> as Shl<usize>>::Output

应用 << 运算符后的结果类型。

fn shl(self, other: &usize) -> <Saturating<u64> as Shl<usize>>::Output

执行 << 操作。

impl Shl<&'_ usize> for Saturating<u128>

type Output = <Saturating<u128> as Shl<usize>>::Output

应用 << 运算符后的结果类型。

fn shl(self, other: &usize) -> <Saturating<u128> as Shl<usize>>::Output

执行 << 操作。

impl Shl<&'_ usize> for &Saturating<u128>

type Output = <Saturating<u128> as Shl<usize>>::Output

应用 << 运算符后的结果类型。

fn shl(self, other: &usize) -> <Saturating<u128> as Shl<usize>>::Output

执行 << 操作。

impl Shl<usize> for Saturating<u8>

type Output = Saturating<u8>

应用 << 运算符后的结果类型。

fn shl(self, other: usize) -> Saturating<u8>

执行 << 操作。

impl<'a> Shl<usize> for &'a Saturating<u8>

type Output = <Saturating<u8> as Shl<usize>>::Output

应用 << 运算符后的结果类型。

fn shl(self, other: usize) -> <Saturating<u8> as Shl<usize>>::Output

执行 << 操作。

impl Shl<usize> for Saturating<usize>

type Output = Saturating<usize>

应用 << 运算符后的结果类型。

fn shl(self, other: usize) -> Saturating<usize>

执行 << 操作。

impl<'a> Shl<usize> for &'a Saturating<usize>

type Output = <Saturating<usize> as Shl<usize>>::Output

应用 << 运算符后的结果类型。

fn shl(self, other: usize) -> <Saturating<usize> as Shl<usize>>::Output

执行 << 操作。

impl Shl<usize> for Saturating<i8>

type Output = Saturating<i8>

应用 << 运算符后的结果类型。

fn shl(self, other: usize) -> Saturating<i8>

执行 << 操作。

impl<'a> Shl<usize> for &'a Saturating<i8>

type Output = <Saturating<i8> as Shl<usize>>::Output

应用 << 运算符后的结果类型。

fn shl(self, other: usize) -> <Saturating<i8> as Shl<usize>>::Output

执行 << 操作。

impl Shl<usize> for Saturating<i16>

type Output = Saturating<i16>

应用 << 运算符后的结果类型。

fn shl(self, other: usize) -> Saturating<i16>

执行 << 操作。

impl<'a> Shl<usize> for &'a Saturating<i16>

type Output = <Saturating<i16> as Shl<usize>>::Output

应用 << 运算符后的结果类型。

fn shl(self, other: usize) -> <Saturating<i16> as Shl<usize>>::Output

执行 << 操作。

impl Shl<usize> for Saturating<i32>

type Output = Saturating<i32>

应用 << 运算符后的结果类型。

fn shl(self, other: usize) -> Saturating<i32>

执行 << 操作。

impl<'a> Shl<usize> for &'a Saturating<i32>

type Output = <Saturating<i32> as Shl<usize>>::Output

应用 << 运算符后的结果类型。

fn shl(self, other: usize) -> <Saturating<i32> as Shl<usize>>::Output

执行 << 操作。

impl Shl<usize> for Saturating<i64>

type Output = Saturating<i64>

应用 << 运算符后的结果类型。

fn shl(self, other: usize) -> Saturating<i64>

执行 << 操作。

impl<'a> Shl<usize> for &'a Saturating<i64>

type Output = <Saturating<i64> as Shl<usize>>::Output

应用 << 运算符后的结果类型。

fn shl(self, other: usize) -> <Saturating<i64> as Shl<usize>>::Output

执行 << 操作。

impl Shl<usize> for Saturating<u16>

type Output = Saturating<u16>

应用 << 运算符后的结果类型。

fn shl(self, other: usize) -> Saturating<u16>

执行 << 操作。

impl Shl<usize> for Saturating<i128>

type Output = Saturating<i128>

应用 << 运算符后的结果类型。

fn shl(self, other: usize) -> Saturating<i128>

执行 << 操作。

impl<'a> Shl<usize> for &'a Saturating<i128>

type Output = <Saturating<i128> as Shl<usize>>::Output

应用 << 运算符后的结果类型。

fn shl(self, other: usize) -> <Saturating<i128> as Shl<usize>>::Output

执行 << 操作。

impl Shl<usize> for Saturating<isize>

type Output = Saturating<isize>

应用 << 运算符后的结果类型。

fn shl(self, other: usize) -> Saturating<isize>

执行 << 操作。

impl<'a> Shl<usize> for &'a Saturating<isize>

type Output = <Saturating<isize> as Shl<usize>>::Output

应用 << 运算符后的结果类型。

fn shl(self, other: usize) -> <Saturating<isize> as Shl<usize>>::Output

执行 << 操作。

impl<'a> Shl<usize> for &'a Saturating<u16>

type Output = <Saturating<u16> as Shl<usize>>::Output

应用 << 运算符后的结果类型。

fn shl(self, other: usize) -> <Saturating<u16> as Shl<usize>>::Output

执行 << 操作。

impl Shl<usize> for Saturating<u32>

type Output = Saturating<u32>

应用 << 运算符后的结果类型。

fn shl(self, other: usize) -> Saturating<u32>

执行 << 操作。

impl<'a> Shl<usize> for &'a Saturating<u32>

type Output = <Saturating<u32> as Shl<usize>>::Output

应用 << 运算符后的结果类型。

fn shl(self, other: usize) -> <Saturating<u32> as Shl<usize>>::Output

执行 << 操作。

impl Shl<usize> for Saturating<u64>

type Output = Saturating<u64>

应用 << 运算符后的结果类型。

fn shl(self, other: usize) -> Saturating<u64>

执行 << 操作。

impl<'a> Shl<usize> for &'a Saturating<u64>

type Output = <Saturating<u64> as Shl<usize>>::Output

应用 << 运算符后的结果类型。

fn shl(self, other: usize) -> <Saturating<u64> as Shl<usize>>::Output

执行 << 操作。

impl Shl<usize> for Saturating<u128>

type Output = Saturating<u128>

应用 << 运算符后的结果类型。

fn shl(self, other: usize) -> Saturating<u128>

执行 << 操作。

impl<'a> Shl<usize> for &'a Saturating<u128>

type Output = <Saturating<u128> as Shl<usize>>::Output

应用 << 运算符后的结果类型。

fn shl(self, other: usize) -> <Saturating<u128> as Shl<usize>>::Output

执行 << 操作。

impl ShlAssign<&'_ usize> for Saturating<u8>

fn shl_assign(&mut self, other: &usize)

执行 <<= 操作。

impl ShlAssign<&'_ usize> for Saturating<u16>

fn shl_assign(&mut self, other: &usize)

执行 <<= 操作。

impl ShlAssign<&'_ usize> for Saturating<i128>

fn shl_assign(&mut self, other: &usize)

执行 <<= 操作。

impl ShlAssign<&'_ usize> for Saturating<isize>

fn shl_assign(&mut self, other: &usize)

执行 <<= 操作。

impl ShlAssign<&'_ usize> for Saturating<u32>

fn shl_assign(&mut self, other: &usize)

执行 <<= 操作。

impl ShlAssign<&'_ usize> for Saturating<u64>

fn shl_assign(&mut self, other: &usize)

执行 <<= 操作。

impl ShlAssign<&'_ usize> for Saturating<u128>

fn shl_assign(&mut self, other: &usize)

执行 <<= 操作。

impl ShlAssign<&'_ usize> for Saturating<usize>

fn shl_assign(&mut self, other: &usize)

执行 <<= 操作。

impl ShlAssign<&'_ usize> for Saturating<i8>

fn shl_assign(&mut self, other: &usize)

执行 <<= 操作。

impl ShlAssign<&'_ usize> for Saturating<i16>

fn shl_assign(&mut self, other: &usize)

执行 <<= 操作。

impl ShlAssign<&'_ usize> for Saturating<i32>

fn shl_assign(&mut self, other: &usize)

执行 <<= 操作。

impl ShlAssign<&'_ usize> for Saturating<i64>

fn shl_assign(&mut self, other: &usize)

执行 <<= 操作。

impl ShlAssign<usize> for Saturating<u8>

fn shl_assign(&mut self, other: usize)

执行 <<= 操作。

impl ShlAssign<usize> for Saturating<u16>

fn shl_assign(&mut self, other: usize)

执行 <<= 操作。

impl ShlAssign<usize> for Saturating<i128>

fn shl_assign(&mut self, other: usize)

执行 <<= 操作。

impl ShlAssign<usize> for Saturating<isize>

fn shl_assign(&mut self, other: usize)

执行 <<= 操作。

impl ShlAssign<usize> for Saturating<u32>

fn shl_assign(&mut self, other: usize)

执行 <<= 操作。

impl ShlAssign<usize> for Saturating<u64>

fn shl_assign(&mut self, other: usize)

执行 <<= 操作。

impl ShlAssign<usize> for Saturating<u128>

fn shl_assign(&mut self, other: usize)

执行 <<= 操作。

impl ShlAssign<usize> for Saturating<usize>

fn shl_assign(&mut self, other: usize)

执行 <<= 操作。

impl ShlAssign<usize> for Saturating<i8>

fn shl_assign(&mut self, other: usize)

执行 <<= 操作。

impl ShlAssign<usize> for Saturating<i16>

fn shl_assign(&mut self, other: usize)

执行 <<= 操作。

impl ShlAssign<usize> for Saturating<i32>

fn shl_assign(&mut self, other: usize)

执行 <<= 操作。

impl ShlAssign<usize> for Saturating<i64>

fn shl_assign(&mut self, other: usize)

执行 <<= 操作。

impl Shr<&'_ usize> for Saturating<u8>

type Output = <Saturating<u8> as Shr<usize>>::Output

应用 >> 运算符后的结果类型。

fn shr(self, other: &usize) -> <Saturating<u8> as Shr<usize>>::Output

执行 >> 操作。

impl Shr<&'_ usize> for &Saturating<u8>

type Output = <Saturating<u8> as Shr<usize>>::Output

应用 >> 运算符后的结果类型。

fn shr(self, other: &usize) -> <Saturating<u8> as Shr<usize>>::Output

执行 >> 操作。

impl Shr<&'_ usize> for Saturating<usize>

type Output = <Saturating<usize> as Shr<usize>>::Output

应用 >> 运算符后的结果类型。

fn shr(self, other: &usize) -> <Saturating<usize> as Shr<usize>>::Output

执行 >> 操作。

impl Shr<&'_ usize> for &Saturating<usize>

type Output = <Saturating<usize> as Shr<usize>>::Output

应用 >> 运算符后的结果类型。

fn shr(self, other: &usize) -> <Saturating<usize> as Shr<usize>>::Output

执行 >> 操作。

impl Shr<&'_ usize> for Saturating<i8>

type Output = <Saturating<i8> as Shr<usize>>::Output

应用 >> 运算符后的结果类型。

fn shr(self, other: &usize) -> <Saturating<i8> as Shr<usize>>::Output

执行 >> 操作。

impl Shr<&'_ usize> for &Saturating<i8>

type Output = <Saturating<i8> as Shr<usize>>::Output

应用 >> 运算符后的结果类型。

fn shr(self, other: &usize) -> <Saturating<i8> as Shr<usize>>::Output

执行 >> 操作。

impl Shr<&'_ usize> for Saturating<i16>

type Output = <Saturating<i16> as Shr<usize>>::Output

应用 >> 运算符后的结果类型。

fn shr(self, other: &usize) -> <Saturating<i16> as Shr<usize>>::Output

执行 >> 操作。

impl Shr<&'_ usize> for &Saturating<i16>

type Output = <Saturating<i16> as Shr<usize>>::Output

应用 >> 运算符后的结果类型。

fn shr(self, other: &usize) -> <Saturating<i16> as Shr<usize>>::Output

执行 >> 操作。

impl Shr<&'_ usize> for Saturating<i32>

type Output = <Saturating<i32> as Shr<usize>>::Output

应用 >> 运算符后的结果类型。

fn shr(self, other: &usize) -> <Saturating<i32> as Shr<usize>>::Output

执行 >> 操作。

impl Shr<&'_ usize> for &Saturating<i32>

type Output = <Saturating<i32> as Shr<usize>>::Output

应用 >> 运算符后的结果类型。

fn shr(self, other: &usize) -> <Saturating<i32> as Shr<usize>>::Output

执行 >> 操作。

impl Shr<&'_ usize> for Saturating<i64>

type Output = <Saturating<i64> as Shr<usize>>::Output

应用 >> 运算符后的结果类型。

fn shr(self, other: &usize) -> <Saturating<i64> as Shr<usize>>::Output

执行 >> 操作。

impl Shr<&'_ usize> for &Saturating<i64>

type Output = <Saturating<i64> as Shr<usize>>::Output

应用 >> 运算符后的结果类型。

fn shr(self, other: &usize) -> <Saturating<i64> as Shr<usize>>::Output

执行 >> 操作。

impl Shr<&'_ usize> for Saturating<u16>

type Output = <Saturating<u16> as Shr<usize>>::Output

应用 >> 运算符后的结果类型。

fn shr(self, other: &usize) -> <Saturating<u16> as Shr<usize>>::Output

执行 >> 操作。

impl Shr<&'_ usize> for Saturating<i128>

type Output = <Saturating<i128> as Shr<usize>>::Output

应用 >> 运算符后的结果类型。

fn shr(self, other: &usize) -> <Saturating<i128> as Shr<usize>>::Output

执行 >> 操作。

impl Shr<&'_ usize> for &Saturating<i128>

type Output = <Saturating<i128> as Shr<usize>>::Output

应用 >> 运算符后的结果类型。

fn shr(self, other: &usize) -> <Saturating<i128> as Shr<usize>>::Output

执行 >> 操作。

impl Shr<&'_ usize> for Saturating<isize>

type Output = <Saturating<isize> as Shr<usize>>::Output

应用 >> 运算符后的结果类型。

fn shr(self, other: &usize) -> <Saturating<isize> as Shr<usize>>::Output

执行 >> 操作。

impl Shr<&'_ usize> for &Saturating<isize>

type Output = <Saturating<isize> as Shr<usize>>::Output

应用 >> 运算符后的结果类型。

fn shr(self, other: &usize) -> <Saturating<isize> as Shr<usize>>::Output

执行 >> 操作。

impl Shr<&'_ usize> for &Saturating<u16>

type Output = <Saturating<u16> as Shr<usize>>::Output

应用 >> 运算符后的结果类型。

fn shr(self, other: &usize) -> <Saturating<u16> as Shr<usize>>::Output

执行 >> 操作。

impl Shr<&'_ usize> for Saturating<u32>

type Output = <Saturating<u32> as Shr<usize>>::Output

应用 >> 运算符后的结果类型。

fn shr(self, other: &usize) -> <Saturating<u32> as Shr<usize>>::Output

执行 >> 操作。

impl Shr<&'_ usize> for &Saturating<u32>

type Output = <Saturating<u32> as Shr<usize>>::Output

应用 >> 运算符后的结果类型。

fn shr(self, other: &usize) -> <Saturating<u32> as Shr<usize>>::Output

执行 >> 操作。

impl Shr<&'_ usize> for Saturating<u64>

type Output = <Saturating<u64> as Shr<usize>>::Output

应用 >> 运算符后的结果类型。

fn shr(self, other: &usize) -> <Saturating<u64> as Shr<usize>>::Output

执行 >> 操作。

impl Shr<&'_ usize> for &Saturating<u64>

type Output = <Saturating<u64> as Shr<usize>>::Output

应用 >> 运算符后的结果类型。

fn shr(self, other: &usize) -> <Saturating<u64> as Shr<usize>>::Output

执行 >> 操作。

impl Shr<&'_ usize> for Saturating<u128>

type Output = <Saturating<u128> as Shr<usize>>::Output

应用 >> 运算符后的结果类型。

fn shr(self, other: &usize) -> <Saturating<u128> as Shr<usize>>::Output

执行 >> 操作。

impl Shr<&'_ usize> for &Saturating<u128>

type Output = <Saturating<u128> as Shr<usize>>::Output

应用 >> 运算符后的结果类型。

fn shr(self, other: &usize) -> <Saturating<u128> as Shr<usize>>::Output

执行 >> 操作。

impl Shr<usize> for Saturating<u8>

type Output = Saturating<u8>

应用 >> 运算符后的结果类型。

fn shr(self, other: usize) -> Saturating<u8>

执行 >> 操作。

impl<'a> Shr<usize> for &'a Saturating<u8>

type Output = <Saturating<u8> as Shr<usize>>::Output

应用 >> 运算符后的结果类型。

fn shr(self, other: usize) -> <Saturating<u8> as Shr<usize>>::Output

执行 >> 操作。

impl Shr<usize> for Saturating<usize>

type Output = Saturating<usize>

应用 >> 运算符后的结果类型。

fn shr(self, other: usize) -> Saturating<usize>

执行 >> 操作。

impl<'a> Shr<usize> for &'a Saturating<usize>

type Output = <Saturating<usize> as Shr<usize>>::Output

应用 >> 运算符后的结果类型。

fn shr(self, other: usize) -> <Saturating<usize> as Shr<usize>>::Output

执行 >> 操作。

impl Shr<usize> for Saturating<i8>

type Output = Saturating<i8>

应用 >> 运算符后的结果类型。

fn shr(self, other: usize) -> Saturating<i8>

执行 >> 操作。

impl<'a> Shr<usize> for &'a Saturating<i8>

type Output = <Saturating<i8> as Shr<usize>>::Output

应用 >> 运算符后的结果类型。

fn shr(self, other: usize) -> <Saturating<i8> as Shr<usize>>::Output

执行 >> 操作。

impl Shr<usize> for Saturating<i16>

type Output = Saturating<i16>

应用 >> 运算符后的结果类型。

fn shr(self, other: usize) -> Saturating<i16>

执行 >> 操作。

impl<'a> Shr<usize> for &'a Saturating<i16>

type Output = <Saturating<i16> as Shr<usize>>::Output

应用 >> 运算符后的结果类型。

fn shr(self, other: usize) -> <Saturating<i16> as Shr<usize>>::Output

执行 >> 操作。

impl Shr<usize> for Saturating<i32>

type Output = Saturating<i32>

应用 >> 运算符后的结果类型。

fn shr(self, other: usize) -> Saturating<i32>

执行 >> 操作。

impl<'a> Shr<usize> for &'a Saturating<i32>

type Output = <Saturating<i32> as Shr<usize>>::Output

应用 >> 运算符后的结果类型。

fn shr(self, other: usize) -> <Saturating<i32> as Shr<usize>>::Output

执行 >> 操作。

impl Shr<usize> for Saturating<i64>

type Output = Saturating<i64>

应用 >> 运算符后的结果类型。

fn shr(self, other: usize) -> Saturating<i64>

执行 >> 操作。

impl<'a> Shr<usize> for &'a Saturating<i64>

type Output = <Saturating<i64> as Shr<usize>>::Output

应用 >> 运算符后的结果类型。

fn shr(self, other: usize) -> <Saturating<i64> as Shr<usize>>::Output

执行 >> 操作。

impl Shr<usize> for Saturating<u16>

type Output = Saturating<u16>

应用 >> 运算符后的结果类型。

fn shr(self, other: usize) -> Saturating<u16>

执行 >> 操作。

impl Shr<usize> for Saturating<i128>

type Output = Saturating<i128>

应用 >> 运算符后的结果类型。

fn shr(self, other: usize) -> Saturating<i128>

执行 >> 操作。

impl<'a> Shr<usize> for &'a Saturating<i128>

type Output = <Saturating<i128> as Shr<usize>>::Output

应用 >> 运算符后的结果类型。

fn shr(self, other: usize) -> <Saturating<i128> as Shr<usize>>::Output

执行 >> 操作。

impl Shr<usize> for Saturating<isize>

type Output = Saturating<isize>

应用 >> 运算符后的结果类型。

fn shr(self, other: usize) -> Saturating<isize>

执行 >> 操作。

impl<'a> Shr<usize> for &'a Saturating<isize>

type Output = <Saturating<isize> as Shr<usize>>::Output

应用 >> 运算符后的结果类型。

fn shr(self, other: usize) -> <Saturating<isize> as Shr<usize>>::Output

执行 >> 操作。

impl<'a> Shr<usize> for &'a Saturating<u16>

type Output = <Saturating<u16> as Shr<usize>>::Output

应用 >> 运算符后的结果类型。

fn shr(self, other: usize) -> <Saturating<u16> as Shr<usize>>::Output

执行 >> 操作。

impl Shr<usize> for Saturating<u32>

type Output = Saturating<u32>

应用 >> 运算符后的结果类型。

fn shr(self, other: usize) -> Saturating<u32>

执行 >> 操作。

impl<'a> Shr<usize> for &'a Saturating<u32>

type Output = <Saturating<u32> as Shr<usize>>::Output

应用 >> 运算符后的结果类型。

fn shr(self, other: usize) -> <Saturating<u32> as Shr<usize>>::Output

执行 >> 操作。

impl Shr<usize> for Saturating<u64>

type Output = Saturating<u64>

应用 >> 运算符后的结果类型。

fn shr(self, other: usize) -> Saturating<u64>

执行 >> 操作。

impl<'a> Shr<usize> for &'a Saturating<u64>

type Output = <Saturating<u64> as Shr<usize>>::Output

应用 >> 运算符后的结果类型。

fn shr(self, other: usize) -> <Saturating<u64> as Shr<usize>>::Output

执行 >> 操作。

impl Shr<usize> for Saturating<u128>

type Output = Saturating<u128>

应用 >> 运算符后的结果类型。

fn shr(self, other: usize) -> Saturating<u128>

执行 >> 操作。

impl<'a> Shr<usize> for &'a Saturating<u128>

type Output = <Saturating<u128> as Shr<usize>>::Output

应用 >> 运算符后的结果类型。

fn shr(self, other: usize) -> <Saturating<u128> as Shr<usize>>::Output

执行 >> 操作。

impl ShrAssign<&'_ usize> for Saturating<u8>

fn shr_assign(&mut self, other: &usize)

执行 >>= 操作。

impl ShrAssign<&'_ usize> for Saturating<u16>

fn shr_assign(&mut self, other: &usize)

执行 >>= 操作。

impl ShrAssign<&'_ usize> for Saturating<i128>

fn shr_assign(&mut self, other: &usize)

执行 >>= 操作。

impl ShrAssign<&'_ usize> for Saturating<isize>

fn shr_assign(&mut self, other: &usize)

执行 >>= 操作。

impl ShrAssign<&'_ usize> for Saturating<u32>

fn shr_assign(&mut self, other: &usize)

执行 >>= 操作。

impl ShrAssign<&'_ usize> for Saturating<u64>

fn shr_assign(&mut self, other: &usize)

执行 >>= 操作。

impl ShrAssign<&'_ usize> for Saturating<u128>

fn shr_assign(&mut self, other: &usize)

执行 >>= 操作。

impl ShrAssign<&'_ usize> for Saturating<usize>

fn shr_assign(&mut self, other: &usize)

执行 >>= 操作。

impl ShrAssign<&'_ usize> for Saturating<i8>

fn shr_assign(&mut self, other: &usize)

执行 >>= 操作。

impl ShrAssign<&'_ usize> for Saturating<i16>

fn shr_assign(&mut self, other: &usize)

执行 >>= 操作。

impl ShrAssign<&'_ usize> for Saturating<i32>

fn shr_assign(&mut self, other: &usize)

执行 >>= 操作。

impl ShrAssign<&'_ usize> for Saturating<i64>

fn shr_assign(&mut self, other: &usize)

执行 >>= 操作。

impl ShrAssign<usize> for Saturating<u8>

fn shr_assign(&mut self, other: usize)

执行 >>= 操作。

impl ShrAssign<usize> for Saturating<u16>

fn shr_assign(&mut self, other: usize)

执行 >>= 操作。

impl ShrAssign<usize> for Saturating<i128>

fn shr_assign(&mut self, other: usize)

执行 >>= 操作。

impl ShrAssign<usize> for Saturating<isize>

fn shr_assign(&mut self, other: usize)

执行 >>= 操作。

impl ShrAssign<usize> for Saturating<u32>

fn shr_assign(&mut self, other: usize)

执行 >>= 操作。

impl ShrAssign<usize> for Saturating<u64>

fn shr_assign(&mut self, other: usize)

执行 >>= 操作。

impl ShrAssign<usize> for Saturating<u128>

fn shr_assign(&mut self, other: usize)

执行 >>= 操作。

impl ShrAssign<usize> for Saturating<usize>

fn shr_assign(&mut self, other: usize)

执行 >>= 操作。

impl ShrAssign<usize> for Saturating<i8>

fn shr_assign(&mut self, other: usize)

执行 >>= 操作。

impl ShrAssign<usize> for Saturating<i16>

fn shr_assign(&mut self, other: usize)

执行 >>= 操作。

impl ShrAssign<usize> for Saturating<i32>

fn shr_assign(&mut self, other: usize)

执行 >>= 操作。

impl ShrAssign<usize> for Saturating<i64>

fn shr_assign(&mut self, other: usize)

执行 >>= 操作。

impl Sub<&'_ Saturating<i128>> for Saturating<i128>

type Output = <Saturating<i128> as Sub<Saturating<i128>>>::Output

应用 - 运算符后的结果类型。

fn sub(
    self,
    other: &Saturating<i128>
) -> <Saturating<i128> as Sub<Saturating<i128>>>::Output

执行 - 操作。

impl Sub<&'_ Saturating<i128>> for &Saturating<i128>

type Output = <Saturating<i128> as Sub<Saturating<i128>>>::Output

应用 - 运算符后的结果类型。

fn sub(
    self,
    other: &Saturating<i128>
) -> <Saturating<i128> as Sub<Saturating<i128>>>::Output

执行 - 操作。

impl Sub<&'_ Saturating<i16>> for Saturating<i16>

type Output = <Saturating<i16> as Sub<Saturating<i16>>>::Output

应用 - 运算符后的结果类型。

fn sub(
    self,
    other: &Saturating<i16>
) -> <Saturating<i16> as Sub<Saturating<i16>>>::Output

执行 - 操作。

impl Sub<&'_ Saturating<i16>> for &Saturating<i16>

type Output = <Saturating<i16> as Sub<Saturating<i16>>>::Output

应用 - 运算符后的结果类型。

fn sub(
    self,
    other: &Saturating<i16>
) -> <Saturating<i16> as Sub<Saturating<i16>>>::Output

执行 - 操作。

impl Sub<&'_ Saturating<i32>> for Saturating<i32>

type Output = <Saturating<i32> as Sub<Saturating<i32>>>::Output

应用 - 运算符后的结果类型。

fn sub(
    self,
    other: &Saturating<i32>
) -> <Saturating<i32> as Sub<Saturating<i32>>>::Output

执行 - 操作。

impl Sub<&'_ Saturating<i32>> for &Saturating<i32>

type Output = <Saturating<i32> as Sub<Saturating<i32>>>::Output

应用 - 运算符后的结果类型。

fn sub(
    self,
    other: &Saturating<i32>
) -> <Saturating<i32> as Sub<Saturating<i32>>>::Output

执行 - 操作。

impl Sub<&'_ Saturating<i64>> for Saturating<i64>

type Output = <Saturating<i64> as Sub<Saturating<i64>>>::Output

应用 - 运算符后的结果类型。

fn sub(
    self,
    other: &Saturating<i64>
) -> <Saturating<i64> as Sub<Saturating<i64>>>::Output

执行 - 操作。

impl Sub<&'_ Saturating<i64>> for &Saturating<i64>

type Output = <Saturating<i64> as Sub<Saturating<i64>>>::Output

应用 - 运算符后的结果类型。

fn sub(
    self,
    other: &Saturating<i64>
) -> <Saturating<i64> as Sub<Saturating<i64>>>::Output

执行 - 操作。

impl Sub<&'_ Saturating<i8>> for Saturating<i8>

type Output = <Saturating<i8> as Sub<Saturating<i8>>>::Output

应用 - 运算符后的结果类型。

fn sub(
    self,
    other: &Saturating<i8>
) -> <Saturating<i8> as Sub<Saturating<i8>>>::Output

执行 - 操作。

impl Sub<&'_ Saturating<i8>> for &Saturating<i8>

type Output = <Saturating<i8> as Sub<Saturating<i8>>>::Output

应用 - 运算符后的结果类型。

fn sub(
    self,
    other: &Saturating<i8>
) -> <Saturating<i8> as Sub<Saturating<i8>>>::Output

执行 - 操作。

impl Sub<&'_ Saturating<isize>> for Saturating<isize>

type Output = <Saturating<isize> as Sub<Saturating<isize>>>::Output

应用 - 运算符后的结果类型。

fn sub(
    self,
    other: &Saturating<isize>
) -> <Saturating<isize> as Sub<Saturating<isize>>>::Output

执行 - 操作。

impl Sub<&'_ Saturating<isize>> for &Saturating<isize>

type Output = <Saturating<isize> as Sub<Saturating<isize>>>::Output

应用 - 运算符后的结果类型。

fn sub(
    self,
    other: &Saturating<isize>
) -> <Saturating<isize> as Sub<Saturating<isize>>>::Output

执行 - 操作。

impl Sub<&'_ Saturating<u128>> for Saturating<u128>

type Output = <Saturating<u128> as Sub<Saturating<u128>>>::Output

应用 - 运算符后的结果类型。

fn sub(
    self,
    other: &Saturating<u128>
) -> <Saturating<u128> as Sub<Saturating<u128>>>::Output

执行 - 操作。

impl Sub<&'_ Saturating<u128>> for &Saturating<u128>

type Output = <Saturating<u128> as Sub<Saturating<u128>>>::Output

应用 - 运算符后的结果类型。

fn sub(
    self,
    other: &Saturating<u128>
) -> <Saturating<u128> as Sub<Saturating<u128>>>::Output

执行 - 操作。

impl Sub<&'_ Saturating<u16>> for Saturating<u16>

type Output = <Saturating<u16> as Sub<Saturating<u16>>>::Output

应用 - 运算符后的结果类型。

fn sub(
    self,
    other: &Saturating<u16>
) -> <Saturating<u16> as Sub<Saturating<u16>>>::Output

执行 - 操作。

impl Sub<&'_ Saturating<u16>> for &Saturating<u16>

type Output = <Saturating<u16> as Sub<Saturating<u16>>>::Output

应用 - 运算符后的结果类型。

fn sub(
    self,
    other: &Saturating<u16>
) -> <Saturating<u16> as Sub<Saturating<u16>>>::Output

执行 - 操作。

impl Sub<&'_ Saturating<u32>> for Saturating<u32>

type Output = <Saturating<u32> as Sub<Saturating<u32>>>::Output

应用 - 运算符后的结果类型。

fn sub(
    self,
    other: &Saturating<u32>
) -> <Saturating<u32> as Sub<Saturating<u32>>>::Output

执行 - 操作。

impl Sub<&'_ Saturating<u32>> for &Saturating<u32>

type Output = <Saturating<u32> as Sub<Saturating<u32>>>::Output

应用 - 运算符后的结果类型。

fn sub(
    self,
    other: &Saturating<u32>
) -> <Saturating<u32> as Sub<Saturating<u32>>>::Output

执行 - 操作。

impl Sub<&'_ Saturating<u64>> for Saturating<u64>

type Output = <Saturating<u64> as Sub<Saturating<u64>>>::Output

应用 - 运算符后的结果类型。

fn sub(
    self,
    other: &Saturating<u64>
) -> <Saturating<u64> as Sub<Saturating<u64>>>::Output

执行 - 操作。

impl Sub<&'_ Saturating<u64>> for &Saturating<u64>

type Output = <Saturating<u64> as Sub<Saturating<u64>>>::Output

应用 - 运算符后的结果类型。

fn sub(
    self,
    other: &Saturating<u64>
) -> <Saturating<u64> as Sub<Saturating<u64>>>::Output

执行 - 操作。

impl Sub<&'_ Saturating<u8>> for Saturating<u8>

type Output = <Saturating<u8> as Sub<Saturating<u8>>>::Output

应用 - 运算符后的结果类型。

fn sub(
    self,
    other: &Saturating<u8>
) -> <Saturating<u8> as Sub<Saturating<u8>>>::Output

执行 - 操作。

impl Sub<&'_ Saturating<u8>> for &Saturating<u8>

type Output = <Saturating<u8> as Sub<Saturating<u8>>>::Output

应用 - 运算符后的结果类型。

fn sub(
    self,
    other: &Saturating<u8>
) -> <Saturating<u8> as Sub<Saturating<u8>>>::Output

执行 - 操作。

impl Sub<&'_ Saturating<usize>> for Saturating<usize>

type Output = <Saturating<usize> as Sub<Saturating<usize>>>::Output

应用 - 运算符后的结果类型。

fn sub(
    self,
    other: &Saturating<usize>
) -> <Saturating<usize> as Sub<Saturating<usize>>>::Output

执行 - 操作。

impl Sub<&'_ Saturating<usize>> for &Saturating<usize>

type Output = <Saturating<usize> as Sub<Saturating<usize>>>::Output

应用 - 运算符后的结果类型。

fn sub(
    self,
    other: &Saturating<usize>
) -> <Saturating<usize> as Sub<Saturating<usize>>>::Output

执行 - 操作。

impl Sub<Saturating<i128>> for Saturating<i128>

type Output = Saturating<i128>

应用 - 运算符后的结果类型。

fn sub(self, other: Saturating<i128>) -> Saturating<i128>

执行 - 操作。

impl<'a> Sub<Saturating<i128>> for &'a Saturating<i128>

type Output = <Saturating<i128> as Sub<Saturating<i128>>>::Output

应用 - 运算符后的结果类型。

fn sub(
    self,
    other: Saturating<i128>
) -> <Saturating<i128> as Sub<Saturating<i128>>>::Output

执行 - 操作。

impl Sub<Saturating<i16>> for Saturating<i16>

type Output = Saturating<i16>

应用 - 运算符后的结果类型。

fn sub(self, other: Saturating<i16>) -> Saturating<i16>

执行 - 操作。

impl<'a> Sub<Saturating<i16>> for &'a Saturating<i16>

type Output = <Saturating<i16> as Sub<Saturating<i16>>>::Output

应用 - 运算符后的结果类型。

fn sub(
    self,
    other: Saturating<i16>
) -> <Saturating<i16> as Sub<Saturating<i16>>>::Output

执行 - 操作。

impl Sub<Saturating<i32>> for Saturating<i32>

type Output = Saturating<i32>

应用 - 运算符后的结果类型。

fn sub(self, other: Saturating<i32>) -> Saturating<i32>

执行 - 操作。

impl<'a> Sub<Saturating<i32>> for &'a Saturating<i32>

type Output = <Saturating<i32> as Sub<Saturating<i32>>>::Output

应用 - 运算符后的结果类型。

fn sub(
    self,
    other: Saturating<i32>
) -> <Saturating<i32> as Sub<Saturating<i32>>>::Output

执行 - 操作。

impl Sub<Saturating<i64>> for Saturating<i64>

type Output = Saturating<i64>

应用 - 运算符后的结果类型。

fn sub(self, other: Saturating<i64>) -> Saturating<i64>

执行 - 操作。

impl<'a> Sub<Saturating<i64>> for &'a Saturating<i64>

type Output = <Saturating<i64> as Sub<Saturating<i64>>>::Output

应用 - 运算符后的结果类型。

fn sub(
    self,
    other: Saturating<i64>
) -> <Saturating<i64> as Sub<Saturating<i64>>>::Output

执行 - 操作。

impl Sub<Saturating<i8>> for Saturating<i8>

type Output = Saturating<i8>

应用 - 运算符后的结果类型。

fn sub(self, other: Saturating<i8>) -> Saturating<i8>

执行 - 操作。

impl<'a> Sub<Saturating<i8>> for &'a Saturating<i8>

type Output = <Saturating<i8> as Sub<Saturating<i8>>>::Output

应用 - 运算符后的结果类型。

fn sub(
    self,
    other: Saturating<i8>
) -> <Saturating<i8> as Sub<Saturating<i8>>>::Output

执行 - 操作。

impl Sub<Saturating<isize>> for Saturating<isize>

type Output = Saturating<isize>

应用 - 运算符后的结果类型。

fn sub(self, other: Saturating<isize>) -> Saturating<isize>

执行 - 操作。

impl<'a> Sub<Saturating<isize>> for &'a Saturating<isize>

type Output = <Saturating<isize> as Sub<Saturating<isize>>>::Output

应用 - 运算符后的结果类型。

fn sub(
    self,
    other: Saturating<isize>
) -> <Saturating<isize> as Sub<Saturating<isize>>>::Output

执行 - 操作。

impl Sub<Saturating<u128>> for Saturating<u128>

type Output = Saturating<u128>

应用 - 运算符后的结果类型。

fn sub(self, other: Saturating<u128>) -> Saturating<u128>

执行 - 操作。

impl<'a> Sub<Saturating<u128>> for &'a Saturating<u128>

type Output = <Saturating<u128> as Sub<Saturating<u128>>>::Output

应用 - 运算符后的结果类型。

fn sub(
    self,
    other: Saturating<u128>
) -> <Saturating<u128> as Sub<Saturating<u128>>>::Output

执行 - 操作。

impl Sub<Saturating<u16>> for Saturating<u16>

type Output = Saturating<u16>

应用 - 运算符后的结果类型。

fn sub(self, other: Saturating<u16>) -> Saturating<u16>

执行 - 操作。

impl<'a> Sub<Saturating<u16>> for &'a Saturating<u16>

type Output = <Saturating<u16> as Sub<Saturating<u16>>>::Output

应用 - 运算符后的结果类型。

fn sub(
    self,
    other: Saturating<u16>
) -> <Saturating<u16> as Sub<Saturating<u16>>>::Output

执行 - 操作。

impl Sub<Saturating<u32>> for Saturating<u32>

type Output = Saturating<u32>

应用 - 运算符后的结果类型。

fn sub(self, other: Saturating<u32>) -> Saturating<u32>

执行 - 操作。

impl<'a> Sub<Saturating<u32>> for &'a Saturating<u32>

type Output = <Saturating<u32> as Sub<Saturating<u32>>>::Output

应用 - 运算符后的结果类型。

fn sub(
    self,
    other: Saturating<u32>
) -> <Saturating<u32> as Sub<Saturating<u32>>>::Output

执行 - 操作。

impl Sub<Saturating<u64>> for Saturating<u64>

type Output = Saturating<u64>

应用 - 运算符后的结果类型。

fn sub(self, other: Saturating<u64>) -> Saturating<u64>

执行 - 操作。

impl<'a> Sub<Saturating<u64>> for &'a Saturating<u64>

type Output = <Saturating<u64> as Sub<Saturating<u64>>>::Output

应用 - 运算符后的结果类型。

fn sub(
    self,
    other: Saturating<u64>
) -> <Saturating<u64> as Sub<Saturating<u64>>>::Output

执行 - 操作。

impl Sub<Saturating<u8>> for Saturating<u8>

type Output = Saturating<u8>

应用 - 运算符后的结果类型。

fn sub(self, other: Saturating<u8>) -> Saturating<u8>

执行 - 操作。

impl<'a> Sub<Saturating<u8>> for &'a Saturating<u8>

type Output = <Saturating<u8> as Sub<Saturating<u8>>>::Output

应用 - 运算符后的结果类型。

fn sub(
    self,
    other: Saturating<u8>
) -> <Saturating<u8> as Sub<Saturating<u8>>>::Output

执行 - 操作。

impl Sub<Saturating<usize>> for Saturating<usize>

type Output = Saturating<usize>

应用 - 运算符后的结果类型。

fn sub(self, other: Saturating<usize>) -> Saturating<usize>

执行 - 操作。

impl<'a> Sub<Saturating<usize>> for &'a Saturating<usize>

type Output = <Saturating<usize> as Sub<Saturating<usize>>>::Output

应用 - 运算符后的结果类型。

fn sub(
    self,
    other: Saturating<usize>
) -> <Saturating<usize> as Sub<Saturating<usize>>>::Output

执行 - 操作。

impl SubAssign<&'_ Saturating<i128>> for Saturating<i128>

fn sub_assign(&mut self, other: &Saturating<i128>)

执行 -= 操作。

impl SubAssign<&'_ Saturating<i16>> for Saturating<i16>

fn sub_assign(&mut self, other: &Saturating<i16>)

执行 -= 操作。

impl SubAssign<&'_ Saturating<i32>> for Saturating<i32>

fn sub_assign(&mut self, other: &Saturating<i32>)

执行 -= 操作。

impl SubAssign<&'_ Saturating<i64>> for Saturating<i64>

fn sub_assign(&mut self, other: &Saturating<i64>)

执行 -= 操作。

impl SubAssign<&'_ Saturating<i8>> for Saturating<i8>

fn sub_assign(&mut self, other: &Saturating<i8>)

执行 -= 操作。

impl SubAssign<&'_ Saturating<isize>> for Saturating<isize>

fn sub_assign(&mut self, other: &Saturating<isize>)

执行 -= 操作。

impl SubAssign<&'_ Saturating<u128>> for Saturating<u128>

fn sub_assign(&mut self, other: &Saturating<u128>)

执行 -= 操作。

impl SubAssign<&'_ Saturating<u16>> for Saturating<u16>

fn sub_assign(&mut self, other: &Saturating<u16>)

执行 -= 操作。

impl SubAssign<&'_ Saturating<u32>> for Saturating<u32>

fn sub_assign(&mut self, other: &Saturating<u32>)

执行 -= 操作。

impl SubAssign<&'_ Saturating<u64>> for Saturating<u64>

fn sub_assign(&mut self, other: &Saturating<u64>)

执行 -= 操作。

impl SubAssign<&'_ Saturating<u8>> for Saturating<u8>

fn sub_assign(&mut self, other: &Saturating<u8>)

执行 -= 操作。

impl SubAssign<&'_ Saturating<usize>> for Saturating<usize>

fn sub_assign(&mut self, other: &Saturating<usize>)

执行 -= 操作。

impl SubAssign<Saturating<i128>> for Saturating<i128>

fn sub_assign(&mut self, other: Saturating<i128>)

执行 -= 操作。

impl SubAssign<Saturating<i16>> for Saturating<i16>

fn sub_assign(&mut self, other: Saturating<i16>)

执行 -= 操作。

impl SubAssign<Saturating<i32>> for Saturating<i32>

fn sub_assign(&mut self, other: Saturating<i32>)

执行 -= 操作。

impl SubAssign<Saturating<i64>> for Saturating<i64>

fn sub_assign(&mut self, other: Saturating<i64>)

执行 -= 操作。

impl SubAssign<Saturating<i8>> for Saturating<i8>

fn sub_assign(&mut self, other: Saturating<i8>)

执行 -= 操作。

impl SubAssign<Saturating<isize>> for Saturating<isize>

fn sub_assign(&mut self, other: Saturating<isize>)

执行 -= 操作。

impl SubAssign<Saturating<u128>> for Saturating<u128>

fn sub_assign(&mut self, other: Saturating<u128>)

执行 -= 操作。

impl SubAssign<Saturating<u16>> for Saturating<u16>

fn sub_assign(&mut self, other: Saturating<u16>)

执行 -= 操作。

impl SubAssign<Saturating<u32>> for Saturating<u32>

fn sub_assign(&mut self, other: Saturating<u32>)

执行 -= 操作。

impl SubAssign<Saturating<u64>> for Saturating<u64>

fn sub_assign(&mut self, other: Saturating<u64>)

执行 -= 操作。

impl SubAssign<Saturating<u8>> for Saturating<u8>

fn sub_assign(&mut self, other: Saturating<u8>)

执行 -= 操作。

impl SubAssign<Saturating<usize>> for Saturating<usize>

fn sub_assign(&mut self, other: Saturating<usize>)

执行 -= 操作。

impl<T: UpperHex> UpperHex for Saturating<T>

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

使用给定的格式化程序格式化该值。

impl<T: Copy> Copy for Saturating<T>

impl<T: Eq> Eq for Saturating<T>

impl<T> StructuralEq for Saturating<T>

impl<T> StructuralPartialEq for Saturating<T>