Struct Bounded 

pub struct Bounded<T: Integer, const N: u32>(/* private fields */);

An integer value that requires only the N less significant bits of the wrapped type to be encoded.

This limits the number of usable bits in the wrapped integer type, and thus the stored value to a narrower range, which provides guarantees that can be useful when working with in e.g. bitfields.

Invariants

• N is greater than 0.
• N is less than or equal to T::BITS.
• Stored values can be represented with at most N bits.

Examples

The preferred way to create values is through constants and the Bounded::new family of constructors, as they trigger a build error if the type invariants cannot be withheld.

use kernel::num::Bounded;

// An unsigned 8-bit integer, of which only the 4 LSBs are used.
// The value `15` is statically validated to fit that constraint at build time.
let v = Bounded::<u8, 4>::new::<15>();
assert_eq!(v.get(), 15);

// Same using signed values.
let v = Bounded::<i8, 4>::new::<-8>();
assert_eq!(v.get(), -8);

// This doesn't build: a `u8` is smaller than the requested 9 bits.
// let _ = Bounded::<u8, 9>::new::<10>();

// This also doesn't build: the requested value doesn't fit within 4 signed bits.
// let _ = Bounded::<i8, 4>::new::<8>();

Values can also be validated at runtime with Bounded::try_new.

use kernel::num::Bounded;

//  This succeeds because `15` can be represented with 4 unsigned bits.
assert!(Bounded::<u8, 4>::try_new(15).is_some());

// This fails because `16` cannot be represented with 4 unsigned bits.
assert!(Bounded::<u8, 4>::try_new(16).is_none());

Non-constant expressions can be validated at build-time thanks to compiler optimizations. This should be used with caution, on simple expressions only.

use kernel::num::Bounded;

// Here the compiler can infer from the mask that the type invariants are not violated, even
// though the value returned by `some_number` is not statically known.
let v = Bounded::<u32, 4>::from_expr(some_number() & 0xf);

Comparison and arithmetic operations are supported on Boundeds with a compatible backing type, regardless of their number of valid bits.

use kernel::num::Bounded;

let v1 = Bounded::<u32, 8>::new::<4>();
let v2 = Bounded::<u32, 4>::new::<15>();

assert!(v1 != v2);
assert!(v1 < v2);
assert_eq!(v1 + v2, 19);
assert_eq!(v2 % v1, 3);

These operations are also supported between a Bounded and its backing type.

use kernel::num::Bounded;

let v = Bounded::<u8, 4>::new::<15>();

assert!(v == 15);
assert!(v > 12);
assert_eq!(v + 5, 20);
assert_eq!(v / 3, 5);

A change of backing types is possible using Bounded::cast, and the number of valid bits can be extended or reduced with Bounded::extend and Bounded::try_shrink.

use kernel::num::Bounded;

let v = Bounded::<u32, 12>::new::<127>();

// Changes backing type from `u32` to `u16`.
let _: Bounded<u16, 12> = v.cast();

// This does not build, as `u8` is smaller than 12 bits.
// let _: Bounded<u8, 12> = v.cast();

// We can safely extend the number of bits...
let _ = v.extend::<15>();

// ... to the limits of the backing type. This doesn't build as a `u32` cannot contain 33 bits.
// let _ = v.extend::<33>();

// Reducing the number of bits is validated at runtime. This works because `127` can be
// represented with 8 bits.
assert!(v.try_shrink::<8>().is_some());

// ... but not with 6, so this fails.
assert!(v.try_shrink::<6>().is_none());

Infallible conversions from a primitive integer to a large-enough Bounded are supported.

use kernel::num::Bounded;

// This unsigned `Bounded` has 8 bits, so it can represent any `u8`.
let v = Bounded::<u32, 8>::from(128u8);
assert_eq!(v.get(), 128);

// This signed `Bounded` has 8 bits, so it can represent any `i8`.
let v = Bounded::<i32, 8>::from(-128i8);
assert_eq!(v.get(), -128);

// This doesn't build, as this 6-bit `Bounded` does not have enough capacity to represent a
// `u8` (regardless of the passed value).
// let _ = Bounded::<u32, 6>::from(10u8);

// Booleans can be converted into single-bit `Bounded`s.

let v = Bounded::<u64, 1>::from(false);
assert_eq!(v.get(), 0);

let v = Bounded::<u64, 1>::from(true);
assert_eq!(v.get(), 1);

Infallible conversions from a Bounded to a primitive integer are also supported, and dependent on the number of bits used for value representation, not on the backing type.

use kernel::num::Bounded;

// Even though its backing type is `u32`, this `Bounded` only uses 6 bits and thus can safely
// be converted to a `u8`.
let v = Bounded::<u32, 6>::new::<63>();
assert_eq!(u8::from(v), 63);

// Same using signed values.
let v = Bounded::<i32, 8>::new::<-128>();
assert_eq!(i8::from(v), -128);

// This however does not build, as 10 bits won't fit into a `u8` (regardless of the actually
// contained value).
let _v = Bounded::<u32, 10>::new::<10>();
// assert_eq!(u8::from(_v), 10);

// Single-bit `Bounded`s can be converted into a boolean.
let v = Bounded::<u8, 1>::new::<1>();
assert_eq!(bool::from(v), true);

let v = Bounded::<u8, 1>::new::<0>();
assert_eq!(bool::from(v), false);

Fallible conversions from any primitive integer to any Bounded are also supported using the TryIntoBounded trait.

use kernel::num::{Bounded, TryIntoBounded};

// Succeeds because `128` fits into 8 bits.
let v: Option<Bounded<u16, 8>> = 128u32.try_into_bitint();
assert_eq!(v.as_deref().copied(), Some(128));

// Fails because `128` doesn't fits into 6 bits.
let v: Option<Bounded<u16, 6>> = 128u32.try_into_bitint();
assert_eq!(v, None);

Implementations

impl<const N: u32> Bounded<u8, N>

pub const fn new<const VALUE: u8>() -> Self

Creates a Bounded for the constant VALUE.

Fails at build time if VALUE cannot be represented with N bits.

This method should be preferred to Self::from_expr whenever possible.

Examples

use kernel::num::Bounded;

let v = Bounded::<u8, 4>::new::<7>();
assert_eq!(v.get(), 7);

impl<const N: u32> Bounded<u16, N>

pub const fn new<const VALUE: u16>() -> Self

Creates a Bounded for the constant VALUE.

Fails at build time if VALUE cannot be represented with N bits.

This method should be preferred to Self::from_expr whenever possible.

Examples

use kernel::num::Bounded;

let v = Bounded::<u16, 4>::new::<7>();
assert_eq!(v.get(), 7);

impl<const N: u32> Bounded<u32, N>

pub const fn new<const VALUE: u32>() -> Self

Creates a Bounded for the constant VALUE.

Fails at build time if VALUE cannot be represented with N bits.

This method should be preferred to Self::from_expr whenever possible.

Examples

use kernel::num::Bounded;

let v = Bounded::<u32, 4>::new::<7>();
assert_eq!(v.get(), 7);

impl<const N: u32> Bounded<u64, N>

pub const fn new<const VALUE: u64>() -> Self

Creates a Bounded for the constant VALUE.

Fails at build time if VALUE cannot be represented with N bits.

This method should be preferred to Self::from_expr whenever possible.

Examples

use kernel::num::Bounded;

let v = Bounded::<u64, 4>::new::<7>();
assert_eq!(v.get(), 7);

impl<const N: u32> Bounded<usize, N>

pub const fn new<const VALUE: usize>() -> Self

Creates a Bounded for the constant VALUE.

Fails at build time if VALUE cannot be represented with N bits.

This method should be preferred to Self::from_expr whenever possible.

Examples

use kernel::num::Bounded;

let v = Bounded::<usize, 4>::new::<7>();
assert_eq!(v.get(), 7);

impl<const N: u32> Bounded<i8, N>

pub const fn new<const VALUE: i8>() -> Self

Creates a Bounded for the constant VALUE.

Fails at build time if VALUE cannot be represented with N bits.

This method should be preferred to Self::from_expr whenever possible.

Examples

use kernel::num::Bounded;

let v = Bounded::<i8, 4>::new::<7>();
assert_eq!(v.get(), 7);

impl<const N: u32> Bounded<i16, N>

pub const fn new<const VALUE: i16>() -> Self

Creates a Bounded for the constant VALUE.

Fails at build time if VALUE cannot be represented with N bits.

This method should be preferred to Self::from_expr whenever possible.

Examples

use kernel::num::Bounded;

let v = Bounded::<i16, 4>::new::<7>();
assert_eq!(v.get(), 7);

impl<const N: u32> Bounded<i32, N>

pub const fn new<const VALUE: i32>() -> Self

Creates a Bounded for the constant VALUE.

Fails at build time if VALUE cannot be represented with N bits.

This method should be preferred to Self::from_expr whenever possible.

Examples

use kernel::num::Bounded;

let v = Bounded::<i32, 4>::new::<7>();
assert_eq!(v.get(), 7);

impl<const N: u32> Bounded<i64, N>

pub const fn new<const VALUE: i64>() -> Self

Creates a Bounded for the constant VALUE.

Fails at build time if VALUE cannot be represented with N bits.

This method should be preferred to Self::from_expr whenever possible.

Examples

use kernel::num::Bounded;

let v = Bounded::<i64, 4>::new::<7>();
assert_eq!(v.get(), 7);

impl<const N: u32> Bounded<isize, N>

pub const fn new<const VALUE: isize>() -> Self

Creates a Bounded for the constant VALUE.

Fails at build time if VALUE cannot be represented with N bits.

This method should be preferred to Self::from_expr whenever possible.

Examples

use kernel::num::Bounded;

let v = Bounded::<isize, 4>::new::<7>();
assert_eq!(v.get(), 7);

impl<T, const N: u32> Bounded<T, N>

where T: Integer,

pub fn try_new(value: T) -> Option<Self>

Attempts to turn value into a Bounded using N bits.

Returns None if value doesn’t fit within N bits.

Examples

use kernel::num::Bounded;

let v = Bounded::<u8, 1>::try_new(1);
assert_eq!(v.as_deref().copied(), Some(1));

let v = Bounded::<i8, 4>::try_new(-2);
assert_eq!(v.as_deref().copied(), Some(-2));

// `0x1ff` doesn't fit into 8 unsigned bits.
let v = Bounded::<u32, 8>::try_new(0x1ff);
assert_eq!(v, None);

// The range of values representable with 4 bits is `[-8..=7]`. The following tests these
// limits.
let v = Bounded::<i8, 4>::try_new(-8);
assert_eq!(v.map(Bounded::get), Some(-8));
let v = Bounded::<i8, 4>::try_new(-9);
assert_eq!(v, None);
let v = Bounded::<i8, 4>::try_new(7);
assert_eq!(v.map(Bounded::get), Some(7));
let v = Bounded::<i8, 4>::try_new(8);
assert_eq!(v, None);

pub fn from_expr(expr: T) -> Self

Checks that expr is valid for this type at compile-time and build a new value.

This relies on build_assert! and guaranteed optimization to perform validation at compile-time. If expr cannot be proved to be within the requested bounds at compile-time, use the fallible Self::try_new instead.

Limit this to simple, easily provable expressions, and prefer one of the Self::new constructors whenever possible as they statically validate the value instead of relying on compiler optimizations.

Examples

use kernel::num::Bounded;

// Some undefined number.
let v: u32 = some_number();

// Triggers a build error as `v` cannot be asserted to fit within 4 bits...
// let _ = Bounded::<u32, 4>::from_expr(v);

// ... but this works as the compiler can assert the range from the mask.
let _ = Bounded::<u32, 4>::from_expr(v & 0xf);

// These expressions are simple enough to be proven correct, but since they are static the
// `new` constructor should be preferred.
assert_eq!(Bounded::<u8, 1>::from_expr(1).get(), 1);
assert_eq!(Bounded::<u16, 8>::from_expr(0xff).get(), 0xff);

pub fn get(self) -> T

Returns the wrapped value as the backing type.

Examples

use kernel::num::Bounded;

let v = Bounded::<u32, 4>::new::<7>();
assert_eq!(v.get(), 7u32);

pub const fn extend<const M: u32>(self) -> Bounded<T, M>

Increases the number of bits usable for self.

This operation cannot fail.

Examples

use kernel::num::Bounded;

let v = Bounded::<u32, 4>::new::<7>();
let larger_v = v.extend::<12>();
// The contained values are equal even though `larger_v` has a bigger capacity.
assert_eq!(larger_v, v);

pub fn try_shrink<const M: u32>(self) -> Option<Bounded<T, M>>

Attempts to shrink the number of bits usable for self.

Returns None if the value of self cannot be represented within M bits.

Examples

use kernel::num::Bounded;

let v = Bounded::<u32, 12>::new::<7>();

// `7` can be represented using 3 unsigned bits...
let smaller_v = v.try_shrink::<3>();
assert_eq!(smaller_v.as_deref().copied(), Some(7));

// ... but doesn't fit within `2` bits.
assert_eq!(v.try_shrink::<2>(), None);

pub fn cast<U>(self) -> Bounded<U, N>

where U: TryFrom<T> + Integer + Integer<Signedness = T::Signedness>, T: Integer,

Casts self into a Bounded backed by a different storage type, but using the same number of valid bits.

Both T and U must be of same signedness, and U must be at least as large as N bits, or a build error will occur.

Examples

use kernel::num::Bounded;

let v = Bounded::<u32, 12>::new::<127>();

let u16_v: Bounded<u16, 12> = v.cast();
assert_eq!(u16_v.get(), 127);

// This won't build: a `u8` is smaller than the required 12 bits.
// let _: Bounded<u8, 12> = v.cast();

Trait Implementations

impl<T, const N: u32, const M: u32> Add<Bounded<T, M>> for Bounded<T, N>

where T: Integer + Add<Output = T>,

type Output = T

The resulting type after applying the + operator.

fn add(self, rhs: Bounded<T, M>) -> Self::Output

Performs the + operation.

impl<T, const N: u32> Add<T> for Bounded<T, N>

where T: Integer + Add<Output = T>,

type Output = T

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T, const N: u32> Binary for Bounded<T, N>

where T: Integer + Binary,

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

Formats the value using the given formatter.

impl<T, const N: u32, const M: u32> BitAnd<Bounded<T, M>> for Bounded<T, N>

where T: Integer + BitAnd<Output = T>,

type Output = T

The resulting type after applying the & operator.

fn bitand(self, rhs: Bounded<T, M>) -> Self::Output

Performs the & operation.

impl<T, const N: u32> BitAnd<T> for Bounded<T, N>

where T: Integer + BitAnd<Output = T>,

type Output = T

The resulting type after applying the & operator.

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

Performs the & operation.

impl<T, const N: u32, const M: u32> BitOr<Bounded<T, M>> for Bounded<T, N>

where T: Integer + BitOr<Output = T>,

type Output = T

The resulting type after applying the | operator.

fn bitor(self, rhs: Bounded<T, M>) -> Self::Output

Performs the | operation.

impl<T, const N: u32> BitOr<T> for Bounded<T, N>

where T: Integer + BitOr<Output = T>,

type Output = T

The resulting type after applying the | operator.

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

Performs the | operation.

impl<T, const N: u32, const M: u32> BitXor<Bounded<T, M>> for Bounded<T, N>

where T: Integer + BitXor<Output = T>,

type Output = T

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Bounded<T, M>) -> Self::Output

Performs the ^ operation.

impl<T, const N: u32> BitXor<T> for Bounded<T, N>

where T: Integer + BitXor<Output = T>,

type Output = T

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<T: Clone + Integer, const N: u32> Clone for Bounded<T, N>

fn clone(&self) -> Bounded<T, N>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug + Integer, const N: u32> Debug for Bounded<T, N>

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

Formats the value using the given formatter.

impl<T: Default + Integer, const N: u32> Default for Bounded<T, N>

fn default() -> Bounded<T, N>

Returns the “default value” for a type.

impl<T, const N: u32> Deref for Bounded<T, N>

where T: Integer,

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T, const N: u32> Display for Bounded<T, N>

where T: Integer + Display,

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

Formats the value using the given formatter.

impl<T, const N: u32, const M: u32> Div<Bounded<T, M>> for Bounded<T, N>

where T: Integer + Div<Output = T>,

type Output = T

The resulting type after applying the / operator.

fn div(self, rhs: Bounded<T, M>) -> Self::Output

Performs the / operation.

impl<T, const N: u32> Div<T> for Bounded<T, N>

where T: Integer + Div<Output = T>,

type Output = T

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T> From<Bounded<T, 1>> for bool

where T: Integer + Zeroable,

fn from(value: Bounded<T, 1>) -> Self

Converts to this type from the input type.

impl<T, const N: u32> From<Bounded<T, N>> for i16

where i16: Integer + TryFrom<T>, T: Integer<Signedness = <i16 as Integer>::Signedness>, Bounded<T, N>: FitsInXBits<{ _ }>,

Conversion from a Bounded with no more bits than a i16 and of same signedness into i16

fn from(value: Bounded<T, N>) -> i16

Converts to this type from the input type.

impl<T, const N: u32> From<Bounded<T, N>> for i32

where i32: Integer + TryFrom<T>, T: Integer<Signedness = <i32 as Integer>::Signedness>, Bounded<T, N>: FitsInXBits<{ _ }>,

Conversion from a Bounded with no more bits than a i32 and of same signedness into i32

fn from(value: Bounded<T, N>) -> i32

Converts to this type from the input type.

impl<T, const N: u32> From<Bounded<T, N>> for i64

where i64: Integer + TryFrom<T>, T: Integer<Signedness = <i64 as Integer>::Signedness>, Bounded<T, N>: FitsInXBits<{ _ }>,

Conversion from a Bounded with no more bits than a i64 and of same signedness into i64

fn from(value: Bounded<T, N>) -> i64

Converts to this type from the input type.

impl<T, const N: u32> From<Bounded<T, N>> for i8

where i8: Integer + TryFrom<T>, T: Integer<Signedness = <i8 as Integer>::Signedness>, Bounded<T, N>: FitsInXBits<{ _ }>,

Conversion from a Bounded with no more bits than a i8 and of same signedness into i8

fn from(value: Bounded<T, N>) -> i8

Converts to this type from the input type.

impl<T, const N: u32> From<Bounded<T, N>> for isize

where isize: Integer + TryFrom<T>, T: Integer<Signedness = <isize as Integer>::Signedness>, Bounded<T, N>: FitsInXBits<{ _ }>,

Conversion from a Bounded with no more bits than a isize and of same signedness into isize

fn from(value: Bounded<T, N>) -> isize

Converts to this type from the input type.

impl<T, const N: u32> From<Bounded<T, N>> for u16

where u16: Integer + TryFrom<T>, T: Integer<Signedness = <u16 as Integer>::Signedness>, Bounded<T, N>: FitsInXBits<{ _ }>,

Conversion from a Bounded with no more bits than a u16 and of same signedness into u16

fn from(value: Bounded<T, N>) -> u16

Converts to this type from the input type.

impl<T, const N: u32> From<Bounded<T, N>> for u32

where u32: Integer + TryFrom<T>, T: Integer<Signedness = <u32 as Integer>::Signedness>, Bounded<T, N>: FitsInXBits<{ _ }>,

Conversion from a Bounded with no more bits than a u32 and of same signedness into u32

fn from(value: Bounded<T, N>) -> u32

Converts to this type from the input type.

impl<T, const N: u32> From<Bounded<T, N>> for u64

where u64: Integer + TryFrom<T>, T: Integer<Signedness = <u64 as Integer>::Signedness>, Bounded<T, N>: FitsInXBits<{ _ }>,

Conversion from a Bounded with no more bits than a u64 and of same signedness into u64

fn from(value: Bounded<T, N>) -> u64

Converts to this type from the input type.

impl<T, const N: u32> From<Bounded<T, N>> for u8

where u8: Integer + TryFrom<T>, T: Integer<Signedness = <u8 as Integer>::Signedness>, Bounded<T, N>: FitsInXBits<{ _ }>,

Conversion from a Bounded with no more bits than a u8 and of same signedness into u8

fn from(value: Bounded<T, N>) -> u8

Converts to this type from the input type.

impl<T, const N: u32> From<Bounded<T, N>> for usize

where usize: Integer + TryFrom<T>, T: Integer<Signedness = <usize as Integer>::Signedness>, Bounded<T, N>: FitsInXBits<{ _ }>,

Conversion from a Bounded with no more bits than a usize and of same signedness into usize

fn from(value: Bounded<T, N>) -> usize

Converts to this type from the input type.

impl<T, const N: u32> From<bool> for Bounded<T, N>

where T: Integer + From<bool>,

fn from(value: bool) -> Self

Converts to this type from the input type.

impl<T, const N: u32> From<i16> for Bounded<T, N>

where i16: Integer, T: Integer<Signedness = <i16 as Integer>::Signedness> + From<i16>, Self: AtLeastXBits<{ _ }>,

Conversion from a i16 into a Bounded of same signedness with enough bits to store it.

fn from(value: i16) -> Self

Converts to this type from the input type.

impl<T, const N: u32> From<i32> for Bounded<T, N>

where i32: Integer, T: Integer<Signedness = <i32 as Integer>::Signedness> + From<i32>, Self: AtLeastXBits<{ _ }>,

Conversion from a i32 into a Bounded of same signedness with enough bits to store it.

fn from(value: i32) -> Self

Converts to this type from the input type.

impl<T, const N: u32> From<i64> for Bounded<T, N>

where i64: Integer, T: Integer<Signedness = <i64 as Integer>::Signedness> + From<i64>, Self: AtLeastXBits<{ _ }>,

Conversion from a i64 into a Bounded of same signedness with enough bits to store it.

fn from(value: i64) -> Self

Converts to this type from the input type.

impl<T, const N: u32> From<i8> for Bounded<T, N>

where i8: Integer, T: Integer<Signedness = <i8 as Integer>::Signedness> + From<i8>, Self: AtLeastXBits<{ _ }>,

Conversion from a i8 into a Bounded of same signedness with enough bits to store it.

fn from(value: i8) -> Self

Converts to this type from the input type.

impl<T, const N: u32> From<isize> for Bounded<T, N>

where isize: Integer, T: Integer<Signedness = <isize as Integer>::Signedness> + From<isize>, Self: AtLeastXBits<{ _ }>,

Conversion from a isize into a Bounded of same signedness with enough bits to store it.

fn from(value: isize) -> Self

Converts to this type from the input type.

impl<T, const N: u32> From<u16> for Bounded<T, N>

where u16: Integer, T: Integer<Signedness = <u16 as Integer>::Signedness> + From<u16>, Self: AtLeastXBits<{ _ }>,

Conversion from a u16 into a Bounded of same signedness with enough bits to store it.

fn from(value: u16) -> Self

Converts to this type from the input type.

impl<T, const N: u32> From<u32> for Bounded<T, N>

where u32: Integer, T: Integer<Signedness = <u32 as Integer>::Signedness> + From<u32>, Self: AtLeastXBits<{ _ }>,

Conversion from a u32 into a Bounded of same signedness with enough bits to store it.

fn from(value: u32) -> Self

Converts to this type from the input type.

impl<T, const N: u32> From<u64> for Bounded<T, N>

where u64: Integer, T: Integer<Signedness = <u64 as Integer>::Signedness> + From<u64>, Self: AtLeastXBits<{ _ }>,

Conversion from a u64 into a Bounded of same signedness with enough bits to store it.

fn from(value: u64) -> Self

Converts to this type from the input type.

impl<T, const N: u32> From<u8> for Bounded<T, N>

where u8: Integer, T: Integer<Signedness = <u8 as Integer>::Signedness> + From<u8>, Self: AtLeastXBits<{ _ }>,

Conversion from a u8 into a Bounded of same signedness with enough bits to store it.

fn from(value: u8) -> Self

Converts to this type from the input type.

impl<T, const N: u32> From<usize> for Bounded<T, N>

where usize: Integer, T: Integer<Signedness = <usize as Integer>::Signedness> + From<usize>, Self: AtLeastXBits<{ _ }>,

Conversion from a usize into a Bounded of same signedness with enough bits to store it.

fn from(value: usize) -> Self

Converts to this type from the input type.

impl<T: Hash + Integer, const N: u32> Hash for Bounded<T, N>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T, const N: u32> LowerExp for Bounded<T, N>

where T: Integer + LowerExp,

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

Formats the value using the given formatter.

impl<T, const N: u32> LowerHex for Bounded<T, N>

where T: Integer + LowerHex,

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

Formats the value using the given formatter.

impl<T, const N: u32, const M: u32> Mul<Bounded<T, M>> for Bounded<T, N>

where T: Integer + Mul<Output = T>,

type Output = T

The resulting type after applying the * operator.

fn mul(self, rhs: Bounded<T, M>) -> Self::Output

Performs the * operation.

impl<T, const N: u32> Mul<T> for Bounded<T, N>

where T: Integer + Mul<Output = T>,

type Output = T

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T, const N: u32> Neg for Bounded<T, N>

where T: Integer + Neg<Output = T>,

type Output = T

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<T, const N: u32> Not for Bounded<T, N>

where T: Integer + Not<Output = T>,

type Output = T

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<T, const N: u32> Octal for Bounded<T, N>

where T: Integer + Octal,

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

Formats the value using the given formatter.

impl<T, const N: u32> Ord for Bounded<T, N>

where T: Integer + Ord,

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<T, U, const N: u32, const M: u32> PartialEq<Bounded<U, M>> for Bounded<T, N>

where T: Integer + PartialEq<U>, U: Integer,

fn eq(&self, other: &Bounded<U, M>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T, const N: u32> PartialEq<T> for Bounded<T, N>

where T: Integer + PartialEq,

fn eq(&self, other: &T) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T, U, const N: u32, const M: u32> PartialOrd<Bounded<U, M>> for Bounded<T, N>

where T: Integer + PartialOrd<U>, U: Integer,

fn partial_cmp(&self, other: &Bounded<U, M>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T, const N: u32> PartialOrd<T> for Bounded<T, N>

where T: Integer + PartialOrd,

fn partial_cmp(&self, other: &T) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T, const N: u32, const M: u32> Rem<Bounded<T, M>> for Bounded<T, N>

where T: Integer + Rem<Output = T>,

type Output = T

The resulting type after applying the % operator.

fn rem(self, rhs: Bounded<T, M>) -> Self::Output

Performs the % operation.

impl<T, const N: u32> Rem<T> for Bounded<T, N>

where T: Integer + Rem<Output = T>,

type Output = T

The resulting type after applying the % operator.

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

Performs the % operation.

impl<T, const N: u32, const M: u32> Sub<Bounded<T, M>> for Bounded<T, N>

where T: Integer + Sub<Output = T>,

type Output = T

The resulting type after applying the - operator.

fn sub(self, rhs: Bounded<T, M>) -> Self::Output

Performs the - operation.

impl<T, const N: u32> Sub<T> for Bounded<T, N>

where T: Integer + Sub<Output = T>,

type Output = T

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T, const N: u32> UpperExp for Bounded<T, N>

where T: Integer + UpperExp,

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

Formats the value using the given formatter.

impl<T, const N: u32> UpperHex for Bounded<T, N>

where T: Integer + UpperHex,

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

Formats the value using the given formatter.

impl<T: Copy + Integer, const N: u32> Copy for Bounded<T, N>

impl<T, const N: u32> Eq for Bounded<T, N>

where T: Integer,