Struct BoundedI8

pub struct BoundedI8<const MIN: i8, const MAX: i8>(/* private fields */);

An i8 constrained to be in the range MIN..=MAX.

Implementations

impl<const MIN: i8, const MAX: i8> BoundedI8<MIN, MAX>

pub const MIN_VALUE: i8 = MIN

The smallest value this bounded integer can contain.

pub const MAX_VALUE: i8 = MAX

The largest value that this bounded integer can contain.

pub const MIN: Self

The smallest value of the bounded integer.

pub const MAX: Self

The largest value of the bounded integer.

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

Creates a bounded integer if the given value is within the range [MIN, MAX].

pub const fn const_new<const N: i8>() -> Self

Creates a bounded integer whose value is known at compile time.

Causes a compile-time error if N is not in the valid range.

pub const fn new_ref(n: &i8) -> Option<&Self>

Creates a reference to a bounded integer from a reference to a primitive if the given value is within the range [MIN, MAX].

pub const fn new_mut(n: &mut i8) -> Option<&mut Self>

Creates a mutable reference to a bounded integer from a mutable reference to a primitive if the given value is within the range [MIN, MAX].

pub const unsafe fn new_unchecked(n: i8) -> Self

Creates a bounded integer without checking the value.

Safety

The value must not be outside the valid range of values; it must not be less than MIN_VALUE or greater than MAX_VALUE.

pub const unsafe fn new_ref_unchecked(n: &i8) -> &Self

Creates a shared reference to a bounded integer from a shared reference to a primitive.

Safety

The value must not be outside the valid range of values; it must not be less than MIN_VALUE or greater than MAX_VALUE.

pub const unsafe fn new_mut_unchecked(n: &mut i8) -> &mut Self

Creates a mutable reference to a bounded integer from a mutable reference to a primitive.

Safety

The value must not be outside the valid range of values; it must not be less than MIN_VALUE or greater than MAX_VALUE.

pub const fn in_range(n: i8) -> bool

Checks whether the given value is in the range of the bounded integer.

pub const fn new_saturating(n: i8) -> Self

Creates a bounded integer by setting the value to MIN or MAX if it is too low or too high respectively.

pub const fn new_wrapping<__Z: LargerInt>(n: __Z) -> Self

Creates a bounded integer by wrapping using modular arithmetic.

For n in range, this is an identity function, and it wraps for n out of range.

The type parameter Z must be any integer type that is a superset of this one.

pub const fn from_str_radix(src: &str, radix: u32) -> Result<Self, ParseError>

Converts a string slice in a given base to the bounded integer.

Panics

Panics if radix is below 2 or above 36.

pub const fn get(self) -> i8

Returns the value of the bounded integer as a primitive type.

pub const fn get_ref(&self) -> &i8

Returns a shared reference to the value of the bounded integer.

pub const unsafe fn get_mut(&mut self) -> &mut i8

Returns a mutable reference to the value of the bounded integer.

Safety

This value must never be set to a value beyond the range of the bounded integer.

pub const fn abs(self) -> Self

Computes the absolute value of self, panicking if it is out of range.

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

Raises self to the power of exp, using exponentiation by squaring. Panics if it is out of range.

pub const fn div_euclid(self, rhs: i8) -> Self

Calculates the quotient of Euclidean division of self by rhs. Panics if rhs is 0 or the result is out of range.

pub const fn rem_euclid(self, rhs: i8) -> Self

Calculates the least nonnegative remainder of self (mod rhs). Panics if rhs is 0 or the result is out of range.

pub const fn checked_add(self, rhs: i8) -> Option<Self>

Checked integer addition.

Returns None if the result would be out of range.

pub const fn saturating_add(self, rhs: i8) -> Self

Saturating integer addition.

pub const fn wrapping_add(self, rhs: i8) -> Self

Wrapping (modular) integer addition.

pub const fn checked_sub(self, rhs: i8) -> Option<Self>

Checked integer subtraction.

Returns None if the result would be out of range.

pub const fn saturating_sub(self, rhs: i8) -> Self

Saturating integer subtraction.

pub const fn wrapping_sub(self, rhs: i8) -> Self

Wrapping (modular) integer subtraction.

pub const fn checked_mul(self, rhs: i8) -> Option<Self>

Checked integer multiplication.

Returns None if the result would be out of range.

pub const fn saturating_mul(self, rhs: i8) -> Self

Saturating integer multiplication.

pub const fn wrapping_mul(self, rhs: i8) -> Self

Wrapping (modular) integer multiplication.

pub const fn checked_div(self, rhs: i8) -> Option<Self>

Checked integer division.

Returns None if the result would be out of range, or if rhs is zero.

pub const fn wrapping_div(self, rhs: i8) -> Self

Wrapping (modular) integer division.

pub const fn checked_div_euclid(self, rhs: i8) -> Option<Self>

Checked Euclidean division.

Returns None if the result would be out of range, or if rhs is zero.

pub const fn wrapping_div_euclid(self, rhs: i8) -> Self

Wrapping (modular) Euclidean division.

pub const fn checked_rem(self, rhs: i8) -> Option<Self>

Checked integer remainder.

Returns None if the result would be out of range, or if rhs is zero.

pub const fn wrapping_rem(self, rhs: i8) -> Self

Wrapping (modular) integer remainder.

pub const fn checked_rem_euclid(self, rhs: i8) -> Option<Self>

Checked Euclidean remainder.

Returns None if the result would be out of range, or if rhs is zero.

pub const fn wrapping_rem_euclid(self, rhs: i8) -> Self

Wrapping (modular) Euclidean remainder.

pub const fn checked_neg(self) -> Option<Self>

Checked negation.

Returns None if the result would be out of range.

pub const fn saturating_neg(self) -> Self

Saturating negation.

pub const fn wrapping_neg(self) -> Self

Wrapping (modular) negation.

pub const fn checked_abs(self) -> Option<Self>

Checked absolute value.

pub const fn saturating_abs(self) -> Self

Saturating absolute value.

pub const fn wrapping_abs(self) -> Self

Wrapping (modular) absolute value.

pub const fn checked_pow(self, rhs: u32) -> Option<Self>

Checked exponentiation.

pub const fn saturating_pow(self, rhs: u32) -> Self

Saturating exponentiation.

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

Wrapping (modular) exponentiation.

pub const fn checked_shl(self, rhs: u32) -> Option<Self>

Checked shift left.

pub const fn checked_shr(self, rhs: u32) -> Option<Self>

Checked shift right.

Trait Implementations

impl<const MIN: i8, const MAX: i8> Add<&BoundedI8<MIN, MAX>> for &BoundedI8<MIN, MAX>

type Output = BoundedI8<MIN, MAX>

The resulting type after applying the + operator.

fn add(self, rhs: &BoundedI8<MIN, MAX>) -> Self::Output

Performs the + operation.

impl<const MIN: i8, const MAX: i8> Add<&BoundedI8<MIN, MAX>> for &i8

type Output = i8

The resulting type after applying the + operator.

fn add(self, rhs: &BoundedI8<MIN, MAX>) -> Self::Output

Performs the + operation.

impl<const MIN: i8, const MAX: i8> Add<&BoundedI8<MIN, MAX>> for BoundedI8<MIN, MAX>

type Output = BoundedI8<MIN, MAX>

The resulting type after applying the + operator.

fn add(self, rhs: &BoundedI8<MIN, MAX>) -> Self::Output

Performs the + operation.

impl<const MIN: i8, const MAX: i8> Add<&BoundedI8<MIN, MAX>> for i8

type Output = i8

The resulting type after applying the + operator.

fn add(self, rhs: &BoundedI8<MIN, MAX>) -> Self::Output

Performs the + operation.

impl<const MIN: i8, const MAX: i8> Add<&i8> for &BoundedI8<MIN, MAX>

type Output = BoundedI8<MIN, MAX>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<const MIN: i8, const MAX: i8> Add<&i8> for BoundedI8<MIN, MAX>

type Output = BoundedI8<MIN, MAX>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<const MIN: i8, const MAX: i8> Add<BoundedI8<MIN, MAX>> for &BoundedI8<MIN, MAX>

type Output = BoundedI8<MIN, MAX>

The resulting type after applying the + operator.

fn add(self, rhs: BoundedI8<MIN, MAX>) -> Self::Output

Performs the + operation.

impl<const MIN: i8, const MAX: i8> Add<BoundedI8<MIN, MAX>> for &i8

type Output = i8

The resulting type after applying the + operator.

fn add(self, rhs: BoundedI8<MIN, MAX>) -> Self::Output

Performs the + operation.

impl<const MIN: i8, const MAX: i8> Add<BoundedI8<MIN, MAX>> for i8

type Output = i8

The resulting type after applying the + operator.

fn add(self, rhs: BoundedI8<MIN, MAX>) -> Self::Output

Performs the + operation.

impl<const MIN: i8, const MAX: i8> Add<i8> for &BoundedI8<MIN, MAX>

type Output = BoundedI8<MIN, MAX>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<const MIN: i8, const MAX: i8> Add<i8> for BoundedI8<MIN, MAX>

type Output = BoundedI8<MIN, MAX>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<const MIN: i8, const MAX: i8> Add for BoundedI8<MIN, MAX>

type Output = BoundedI8<MIN, MAX>

The resulting type after applying the + operator.

fn add(self, rhs: BoundedI8<MIN, MAX>) -> Self::Output

Performs the + operation.

impl<const MIN: i8, const MAX: i8> AddAssign<&BoundedI8<MIN, MAX>> for BoundedI8<MIN, MAX>

fn add_assign(&mut self, rhs: &BoundedI8<MIN, MAX>)

Performs the += operation.

impl<const MIN: i8, const MAX: i8> AddAssign<&BoundedI8<MIN, MAX>> for i8

fn add_assign(&mut self, rhs: &BoundedI8<MIN, MAX>)

Performs the += operation.

impl<const MIN: i8, const MAX: i8> AddAssign<&i8> for BoundedI8<MIN, MAX>

fn add_assign(&mut self, rhs: &i8)

Performs the += operation.

impl<const MIN: i8, const MAX: i8> AddAssign<BoundedI8<MIN, MAX>> for i8

fn add_assign(&mut self, rhs: BoundedI8<MIN, MAX>)

Performs the += operation.

impl<const MIN: i8, const MAX: i8> AddAssign<i8> for BoundedI8<MIN, MAX>

fn add_assign(&mut self, rhs: i8)

Performs the += operation.

impl<const MIN: i8, const MAX: i8> AddAssign for BoundedI8<MIN, MAX>

fn add_assign(&mut self, rhs: BoundedI8<MIN, MAX>)

Performs the += operation.

impl<'__a, const MIN: i8, const MAX: i8> Arbitrary<'__a> for BoundedI8<MIN, MAX>

Available on crate feature arbitrary1 only.

fn arbitrary(u: &mut Unstructured<'__a>) -> Result<Self>

Generate an arbitrary value of Self from the given unstructured data.

fn size_hint(depth: usize) -> (usize, Option<usize>)

Get a size hint for how many bytes out of an Unstructured this type needs to construct itself.

fn arbitrary_take_rest(u: Unstructured<'a>) -> Result<Self, Error>

Generate an arbitrary value of Self from the entirety of the given unstructured data.

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

Get a size hint for how many bytes out of an Unstructured this type needs to construct itself.

impl<__T, const MIN: i8, const MAX: i8> AsPrimitive<__T> for BoundedI8<MIN, MAX>

where i8: AsPrimitive<__T>, __T: 'static + Copy, Self: 'static,

Available on crate feature num-traits02 only.

fn as_(self) -> __T

Convert a value to another, using the as operator.

impl<const MIN: i8, const MAX: i8> AsRef<i8> for BoundedI8<MIN, MAX>

fn as_ref(&self) -> &i8

Converts this type into a shared reference of the (usually inferred) input type.

impl<const MIN: i8, const MAX: i8> Binary for BoundedI8<MIN, MAX>

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

Formats the value using the given formatter.

impl<const MIN: i8, const MAX: i8> BitAnd<&BoundedI8<MIN, MAX>> for &BoundedI8<MIN, MAX>

type Output = BoundedI8<MIN, MAX>

The resulting type after applying the & operator.

fn bitand(self, rhs: &BoundedI8<MIN, MAX>) -> Self::Output

Performs the & operation.

impl<const MIN: i8, const MAX: i8> BitAnd<&BoundedI8<MIN, MAX>> for &i8

type Output = i8

The resulting type after applying the & operator.

fn bitand(self, rhs: &BoundedI8<MIN, MAX>) -> Self::Output

Performs the & operation.

impl<const MIN: i8, const MAX: i8> BitAnd<&BoundedI8<MIN, MAX>> for BoundedI8<MIN, MAX>

type Output = BoundedI8<MIN, MAX>

The resulting type after applying the & operator.

fn bitand(self, rhs: &BoundedI8<MIN, MAX>) -> Self::Output

Performs the & operation.

impl<const MIN: i8, const MAX: i8> BitAnd<&BoundedI8<MIN, MAX>> for i8

type Output = i8

The resulting type after applying the & operator.

fn bitand(self, rhs: &BoundedI8<MIN, MAX>) -> Self::Output

Performs the & operation.

impl<const MIN: i8, const MAX: i8> BitAnd<&i8> for &BoundedI8<MIN, MAX>

type Output = BoundedI8<MIN, MAX>

The resulting type after applying the & operator.

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

Performs the & operation.

impl<const MIN: i8, const MAX: i8> BitAnd<&i8> for BoundedI8<MIN, MAX>

type Output = BoundedI8<MIN, MAX>

The resulting type after applying the & operator.

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

Performs the & operation.

impl<const MIN: i8, const MAX: i8> BitAnd<BoundedI8<MIN, MAX>> for &BoundedI8<MIN, MAX>

type Output = BoundedI8<MIN, MAX>

The resulting type after applying the & operator.

fn bitand(self, rhs: BoundedI8<MIN, MAX>) -> Self::Output

Performs the & operation.

impl<const MIN: i8, const MAX: i8> BitAnd<BoundedI8<MIN, MAX>> for &i8

type Output = i8

The resulting type after applying the & operator.

fn bitand(self, rhs: BoundedI8<MIN, MAX>) -> Self::Output

Performs the & operation.

impl<const MIN: i8, const MAX: i8> BitAnd<BoundedI8<MIN, MAX>> for i8

type Output = i8

The resulting type after applying the & operator.

fn bitand(self, rhs: BoundedI8<MIN, MAX>) -> Self::Output

Performs the & operation.

impl<const MIN: i8, const MAX: i8> BitAnd<i8> for &BoundedI8<MIN, MAX>

type Output = BoundedI8<MIN, MAX>

The resulting type after applying the & operator.

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

Performs the & operation.

impl<const MIN: i8, const MAX: i8> BitAnd<i8> for BoundedI8<MIN, MAX>

type Output = BoundedI8<MIN, MAX>

The resulting type after applying the & operator.

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

Performs the & operation.

impl<const MIN: i8, const MAX: i8> BitAnd for BoundedI8<MIN, MAX>

type Output = BoundedI8<MIN, MAX>

The resulting type after applying the & operator.

fn bitand(self, rhs: BoundedI8<MIN, MAX>) -> Self::Output

Performs the & operation.

impl<const MIN: i8, const MAX: i8> BitAndAssign<&BoundedI8<MIN, MAX>> for BoundedI8<MIN, MAX>

fn bitand_assign(&mut self, rhs: &BoundedI8<MIN, MAX>)

Performs the &= operation.

impl<const MIN: i8, const MAX: i8> BitAndAssign<&BoundedI8<MIN, MAX>> for i8

fn bitand_assign(&mut self, rhs: &BoundedI8<MIN, MAX>)

Performs the &= operation.

impl<const MIN: i8, const MAX: i8> BitAndAssign<&i8> for BoundedI8<MIN, MAX>

fn bitand_assign(&mut self, rhs: &i8)

Performs the &= operation.

impl<const MIN: i8, const MAX: i8> BitAndAssign<BoundedI8<MIN, MAX>> for i8

fn bitand_assign(&mut self, rhs: BoundedI8<MIN, MAX>)

Performs the &= operation.

impl<const MIN: i8, const MAX: i8> BitAndAssign<i8> for BoundedI8<MIN, MAX>

fn bitand_assign(&mut self, rhs: i8)

Performs the &= operation.

impl<const MIN: i8, const MAX: i8> BitAndAssign for BoundedI8<MIN, MAX>

fn bitand_assign(&mut self, rhs: BoundedI8<MIN, MAX>)

Performs the &= operation.

impl<const MIN: i8, const MAX: i8> BitOr<&BoundedI8<MIN, MAX>> for &BoundedI8<MIN, MAX>

type Output = BoundedI8<MIN, MAX>

The resulting type after applying the | operator.

fn bitor(self, rhs: &BoundedI8<MIN, MAX>) -> Self::Output

Performs the | operation.

impl<const MIN: i8, const MAX: i8> BitOr<&BoundedI8<MIN, MAX>> for &i8

type Output = i8

The resulting type after applying the | operator.

fn bitor(self, rhs: &BoundedI8<MIN, MAX>) -> Self::Output

Performs the | operation.

impl<const MIN: i8, const MAX: i8> BitOr<&BoundedI8<MIN, MAX>> for BoundedI8<MIN, MAX>

type Output = BoundedI8<MIN, MAX>

The resulting type after applying the | operator.

fn bitor(self, rhs: &BoundedI8<MIN, MAX>) -> Self::Output

Performs the | operation.

impl<const MIN: i8, const MAX: i8> BitOr<&BoundedI8<MIN, MAX>> for i8

type Output = i8

The resulting type after applying the | operator.

fn bitor(self, rhs: &BoundedI8<MIN, MAX>) -> Self::Output

Performs the | operation.

impl<const MIN: i8, const MAX: i8> BitOr<&i8> for &BoundedI8<MIN, MAX>

type Output = BoundedI8<MIN, MAX>

The resulting type after applying the | operator.

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

Performs the | operation.

impl<const MIN: i8, const MAX: i8> BitOr<&i8> for BoundedI8<MIN, MAX>

type Output = BoundedI8<MIN, MAX>

The resulting type after applying the | operator.

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

Performs the | operation.

impl<const MIN: i8, const MAX: i8> BitOr<BoundedI8<MIN, MAX>> for &BoundedI8<MIN, MAX>

type Output = BoundedI8<MIN, MAX>

The resulting type after applying the | operator.

fn bitor(self, rhs: BoundedI8<MIN, MAX>) -> Self::Output

Performs the | operation.

impl<const MIN: i8, const MAX: i8> BitOr<BoundedI8<MIN, MAX>> for &i8

type Output = i8

The resulting type after applying the | operator.

fn bitor(self, rhs: BoundedI8<MIN, MAX>) -> Self::Output

Performs the | operation.

impl<const MIN: i8, const MAX: i8> BitOr<BoundedI8<MIN, MAX>> for i8

type Output = i8

The resulting type after applying the | operator.

fn bitor(self, rhs: BoundedI8<MIN, MAX>) -> Self::Output

Performs the | operation.

impl<const MIN: i8, const MAX: i8> BitOr<i8> for &BoundedI8<MIN, MAX>

type Output = BoundedI8<MIN, MAX>

The resulting type after applying the | operator.

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

Performs the | operation.

impl<const MIN: i8, const MAX: i8> BitOr<i8> for BoundedI8<MIN, MAX>

type Output = BoundedI8<MIN, MAX>

The resulting type after applying the | operator.

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

Performs the | operation.

impl<const MIN: i8, const MAX: i8> BitOr for BoundedI8<MIN, MAX>

type Output = BoundedI8<MIN, MAX>

The resulting type after applying the | operator.

fn bitor(self, rhs: BoundedI8<MIN, MAX>) -> Self::Output

Performs the | operation.

impl<const MIN: i8, const MAX: i8> BitOrAssign<&BoundedI8<MIN, MAX>> for BoundedI8<MIN, MAX>

fn bitor_assign(&mut self, rhs: &BoundedI8<MIN, MAX>)

Performs the |= operation.

impl<const MIN: i8, const MAX: i8> BitOrAssign<&BoundedI8<MIN, MAX>> for i8

fn bitor_assign(&mut self, rhs: &BoundedI8<MIN, MAX>)

Performs the |= operation.

impl<const MIN: i8, const MAX: i8> BitOrAssign<&i8> for BoundedI8<MIN, MAX>

fn bitor_assign(&mut self, rhs: &i8)

Performs the |= operation.

impl<const MIN: i8, const MAX: i8> BitOrAssign<BoundedI8<MIN, MAX>> for i8

fn bitor_assign(&mut self, rhs: BoundedI8<MIN, MAX>)

Performs the |= operation.

impl<const MIN: i8, const MAX: i8> BitOrAssign<i8> for BoundedI8<MIN, MAX>

fn bitor_assign(&mut self, rhs: i8)

Performs the |= operation.

impl<const MIN: i8, const MAX: i8> BitOrAssign for BoundedI8<MIN, MAX>

fn bitor_assign(&mut self, rhs: BoundedI8<MIN, MAX>)

Performs the |= operation.

impl<const MIN: i8, const MAX: i8> BitXor<&BoundedI8<MIN, MAX>> for &BoundedI8<MIN, MAX>

type Output = BoundedI8<MIN, MAX>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &BoundedI8<MIN, MAX>) -> Self::Output

Performs the ^ operation.

impl<const MIN: i8, const MAX: i8> BitXor<&BoundedI8<MIN, MAX>> for &i8

type Output = i8

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &BoundedI8<MIN, MAX>) -> Self::Output

Performs the ^ operation.

impl<const MIN: i8, const MAX: i8> BitXor<&BoundedI8<MIN, MAX>> for BoundedI8<MIN, MAX>

type Output = BoundedI8<MIN, MAX>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &BoundedI8<MIN, MAX>) -> Self::Output

Performs the ^ operation.

impl<const MIN: i8, const MAX: i8> BitXor<&BoundedI8<MIN, MAX>> for i8

type Output = i8

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &BoundedI8<MIN, MAX>) -> Self::Output

Performs the ^ operation.

impl<const MIN: i8, const MAX: i8> BitXor<&i8> for &BoundedI8<MIN, MAX>

type Output = BoundedI8<MIN, MAX>

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<const MIN: i8, const MAX: i8> BitXor<&i8> for BoundedI8<MIN, MAX>

type Output = BoundedI8<MIN, MAX>

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<const MIN: i8, const MAX: i8> BitXor<BoundedI8<MIN, MAX>> for &BoundedI8<MIN, MAX>

type Output = BoundedI8<MIN, MAX>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: BoundedI8<MIN, MAX>) -> Self::Output

Performs the ^ operation.

impl<const MIN: i8, const MAX: i8> BitXor<BoundedI8<MIN, MAX>> for &i8

type Output = i8

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: BoundedI8<MIN, MAX>) -> Self::Output

Performs the ^ operation.

impl<const MIN: i8, const MAX: i8> BitXor<BoundedI8<MIN, MAX>> for i8

type Output = i8

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: BoundedI8<MIN, MAX>) -> Self::Output

Performs the ^ operation.

impl<const MIN: i8, const MAX: i8> BitXor<i8> for &BoundedI8<MIN, MAX>

type Output = BoundedI8<MIN, MAX>

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<const MIN: i8, const MAX: i8> BitXor<i8> for BoundedI8<MIN, MAX>

type Output = BoundedI8<MIN, MAX>

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<const MIN: i8, const MAX: i8> BitXor for BoundedI8<MIN, MAX>

type Output = BoundedI8<MIN, MAX>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: BoundedI8<MIN, MAX>) -> Self::Output

Performs the ^ operation.

impl<const MIN: i8, const MAX: i8> BitXorAssign<&BoundedI8<MIN, MAX>> for BoundedI8<MIN, MAX>

fn bitxor_assign(&mut self, rhs: &BoundedI8<MIN, MAX>)

Performs the ^= operation.

impl<const MIN: i8, const MAX: i8> BitXorAssign<&BoundedI8<MIN, MAX>> for i8

fn bitxor_assign(&mut self, rhs: &BoundedI8<MIN, MAX>)

Performs the ^= operation.

impl<const MIN: i8, const MAX: i8> BitXorAssign<&i8> for BoundedI8<MIN, MAX>

fn bitxor_assign(&mut self, rhs: &i8)

Performs the ^= operation.

impl<const MIN: i8, const MAX: i8> BitXorAssign<BoundedI8<MIN, MAX>> for i8

fn bitxor_assign(&mut self, rhs: BoundedI8<MIN, MAX>)

Performs the ^= operation.

impl<const MIN: i8, const MAX: i8> BitXorAssign<i8> for BoundedI8<MIN, MAX>

fn bitxor_assign(&mut self, rhs: i8)

Performs the ^= operation.

impl<const MIN: i8, const MAX: i8> BitXorAssign for BoundedI8<MIN, MAX>

fn bitxor_assign(&mut self, rhs: BoundedI8<MIN, MAX>)

Performs the ^= operation.

impl<const MIN: i8, const MAX: i8> Borrow<i8> for BoundedI8<MIN, MAX>

fn borrow(&self) -> &i8

Immutably borrows from an owned value.

impl<const MIN: i8, const MAX: i8> Bounded for BoundedI8<MIN, MAX>

Available on crate feature num-traits02 only.

fn min_value() -> Self

Returns the smallest finite number this type can represent

fn max_value() -> Self

Returns the largest finite number this type can represent

impl<const MIN: i8, const MAX: i8> CheckedAdd for BoundedI8<MIN, MAX>

Available on crate feature num-traits02 only.

fn checked_add(&self, v: &Self) -> Option<Self>

Adds two numbers, checking for overflow. If overflow happens, None is returned.

impl<const MIN: i8, const MAX: i8> CheckedDiv for BoundedI8<MIN, MAX>

Available on crate feature num-traits02 only.

fn checked_div(&self, v: &Self) -> Option<Self>

Divides two numbers, checking for underflow, overflow and division by zero. If any of that happens, None is returned.

impl<const MIN: i8, const MAX: i8> CheckedMul for BoundedI8<MIN, MAX>

Available on crate feature num-traits02 only.

fn checked_mul(&self, v: &Self) -> Option<Self>

Multiplies two numbers, checking for underflow or overflow. If underflow or overflow happens, None is returned.

impl<const MIN: i8, const MAX: i8> CheckedNeg for BoundedI8<MIN, MAX>

Available on crate feature num-traits02 only.

fn checked_neg(&self) -> Option<Self>

Negates a number, returning None for results that can’t be represented, like signed MIN values that can’t be positive, or non-zero unsigned values that can’t be negative.

impl<const MIN: i8, const MAX: i8> CheckedRem for BoundedI8<MIN, MAX>

Available on crate feature num-traits02 only.

fn checked_rem(&self, v: &Self) -> Option<Self>

Finds the remainder of dividing two numbers, checking for underflow, overflow and division by zero. If any of that happens, None is returned.

impl<const MIN: i8, const MAX: i8> CheckedShl for BoundedI8<MIN, MAX>

Available on crate feature num-traits02 only.

fn checked_shl(&self, v: u32) -> Option<Self>

Checked shift left. Computes self << rhs, returning None if rhs is larger than or equal to the number of bits in self.

impl<const MIN: i8, const MAX: i8> CheckedShr for BoundedI8<MIN, MAX>

Available on crate feature num-traits02 only.

fn checked_shr(&self, v: u32) -> Option<Self>

Checked shift right. Computes self >> rhs, returning None if rhs is larger than or equal to the number of bits in self.

impl<const MIN: i8, const MAX: i8> CheckedSub for BoundedI8<MIN, MAX>

Available on crate feature num-traits02 only.

fn checked_sub(&self, v: &Self) -> Option<Self>

Subtracts two numbers, checking for underflow. If underflow happens, None is returned.

impl<const MIN: i8, const MAX: i8> Clone for BoundedI8<MIN, MAX>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<const MIN: i8, const MAX: i8> Contiguous for BoundedI8<MIN, MAX>

where Self: 'static,

Available on crate feature bytemuck1 only.

const MAX_VALUE: i8 = Self::MAX_VALUE

The upper inclusive bound for valid instances of this type.

const MIN_VALUE: i8 = Self::MIN_VALUE

The lower inclusive bound for valid instances of this type.

type Int = i8

The primitive integer type with an identical representation to this type.

fn from_integer(value: Self::Int) -> Option<Self>

If value is within the range for valid instances of this type, returns Some(converted_value), otherwise, returns None.

fn into_integer(self) -> Self::Int

Perform the conversion from C into the underlying integral type. This mostly exists otherwise generic code would need unsafe for the value as integer

impl<const MIN: i8, const MAX: i8> Debug for BoundedI8<MIN, MAX>

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

Formats the value using the given formatter.

impl<const MAX: i8> Default for BoundedI8<0, MAX>

Available nowhere.

fn default() -> Self

Returns the “default value” for a type.

impl<'__de, const MIN: i8, const MAX: i8> Deserialize<'__de> for BoundedI8<MIN, MAX>

Available on crate feature serde1 only.

fn deserialize<D: Deserializer<'__de>>( deserializer: D, ) -> Result<Self, D::Error>

Deserialize this value from the given Serde deserializer.

impl<const MIN: i8, const MAX: i8> Display for BoundedI8<MIN, MAX>

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

Formats the value using the given formatter.

impl<const MIN: i8, const MAX: i8> Div<&BoundedI8<MIN, MAX>> for &BoundedI8<MIN, MAX>

type Output = BoundedI8<MIN, MAX>

The resulting type after applying the / operator.

fn div(self, rhs: &BoundedI8<MIN, MAX>) -> Self::Output

Performs the / operation.

impl<const MIN: i8, const MAX: i8> Div<&BoundedI8<MIN, MAX>> for &i8

type Output = i8

The resulting type after applying the / operator.

fn div(self, rhs: &BoundedI8<MIN, MAX>) -> Self::Output

Performs the / operation.

impl<const MIN: i8, const MAX: i8> Div<&BoundedI8<MIN, MAX>> for BoundedI8<MIN, MAX>

type Output = BoundedI8<MIN, MAX>

The resulting type after applying the / operator.

fn div(self, rhs: &BoundedI8<MIN, MAX>) -> Self::Output

Performs the / operation.

impl<const MIN: i8, const MAX: i8> Div<&BoundedI8<MIN, MAX>> for i8

type Output = i8

The resulting type after applying the / operator.

fn div(self, rhs: &BoundedI8<MIN, MAX>) -> Self::Output

Performs the / operation.

impl<const MIN: i8, const MAX: i8> Div<&i8> for &BoundedI8<MIN, MAX>

type Output = BoundedI8<MIN, MAX>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<const MIN: i8, const MAX: i8> Div<&i8> for BoundedI8<MIN, MAX>

type Output = BoundedI8<MIN, MAX>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<const MIN: i8, const MAX: i8> Div<BoundedI8<MIN, MAX>> for &BoundedI8<MIN, MAX>

type Output = BoundedI8<MIN, MAX>

The resulting type after applying the / operator.

fn div(self, rhs: BoundedI8<MIN, MAX>) -> Self::Output

Performs the / operation.

impl<const MIN: i8, const MAX: i8> Div<BoundedI8<MIN, MAX>> for &i8

type Output = i8

The resulting type after applying the / operator.

fn div(self, rhs: BoundedI8<MIN, MAX>) -> Self::Output

Performs the / operation.

impl<const MIN: i8, const MAX: i8> Div<BoundedI8<MIN, MAX>> for i8

type Output = i8

The resulting type after applying the / operator.

fn div(self, rhs: BoundedI8<MIN, MAX>) -> Self::Output

Performs the / operation.

impl<const MIN: i8, const MAX: i8> Div<i8> for &BoundedI8<MIN, MAX>

type Output = BoundedI8<MIN, MAX>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<const MIN: i8, const MAX: i8> Div<i8> for BoundedI8<MIN, MAX>

type Output = BoundedI8<MIN, MAX>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<const MIN: i8, const MAX: i8> Div for BoundedI8<MIN, MAX>

type Output = BoundedI8<MIN, MAX>

The resulting type after applying the / operator.

fn div(self, rhs: BoundedI8<MIN, MAX>) -> Self::Output

Performs the / operation.

impl<const MIN: i8, const MAX: i8> DivAssign<&BoundedI8<MIN, MAX>> for BoundedI8<MIN, MAX>

fn div_assign(&mut self, rhs: &BoundedI8<MIN, MAX>)

Performs the /= operation.

impl<const MIN: i8, const MAX: i8> DivAssign<&BoundedI8<MIN, MAX>> for i8

fn div_assign(&mut self, rhs: &BoundedI8<MIN, MAX>)

Performs the /= operation.

impl<const MIN: i8, const MAX: i8> DivAssign<&i8> for BoundedI8<MIN, MAX>

fn div_assign(&mut self, rhs: &i8)

Performs the /= operation.

impl<const MIN: i8, const MAX: i8> DivAssign<BoundedI8<MIN, MAX>> for i8

fn div_assign(&mut self, rhs: BoundedI8<MIN, MAX>)

Performs the /= operation.

impl<const MIN: i8, const MAX: i8> DivAssign<i8> for BoundedI8<MIN, MAX>

fn div_assign(&mut self, rhs: i8)

Performs the /= operation.

impl<const MIN: i8, const MAX: i8> DivAssign for BoundedI8<MIN, MAX>

fn div_assign(&mut self, rhs: BoundedI8<MIN, MAX>)

Performs the /= operation.

impl<const MIN: i8, const MAX: i8> From<BoundedI8<MIN, MAX>> for i128

fn from(bounded: BoundedI8<MIN, MAX>) -> Self

Converts to this type from the input type.

impl<const MIN: i8, const MAX: i8> From<BoundedI8<MIN, MAX>> for i16

fn from(bounded: BoundedI8<MIN, MAX>) -> Self

Converts to this type from the input type.

impl<const MIN: i8, const MAX: i8> From<BoundedI8<MIN, MAX>> for i32

fn from(bounded: BoundedI8<MIN, MAX>) -> Self

Converts to this type from the input type.

impl<const MIN: i8, const MAX: i8> From<BoundedI8<MIN, MAX>> for i64

fn from(bounded: BoundedI8<MIN, MAX>) -> Self

Converts to this type from the input type.

impl<const MIN: i8, const MAX: i8> From<BoundedI8<MIN, MAX>> for i8

fn from(bounded: BoundedI8<MIN, MAX>) -> Self

Converts to this type from the input type.

impl<const MIN: i8, const MAX: i8> From<BoundedI8<MIN, MAX>> for isize

fn from(bounded: BoundedI8<MIN, MAX>) -> Self

Converts to this type from the input type.

impl<const MIN: i8, const MAX: i8> FromPrimitive for BoundedI8<MIN, MAX>

where i8: FromPrimitive,

Available on crate feature num-traits02 only.

fn from_i64(n: i64) -> Option<Self>

Converts an i64 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_u64(n: u64) -> Option<Self>

Converts an u64 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_isize(n: isize) -> Option<Self>

Converts an isize to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_i8(n: i8) -> Option<Self>

Converts an i8 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_i16(n: i16) -> Option<Self>

Converts an i16 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_i32(n: i32) -> Option<Self>

Converts an i32 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_i128(n: i128) -> Option<Self>

Converts an i128 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_usize(n: usize) -> Option<Self>

Converts a usize to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_u8(n: u8) -> Option<Self>

Converts an u8 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_u16(n: u16) -> Option<Self>

Converts an u16 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_u32(n: u32) -> Option<Self>

Converts an u32 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_u128(n: u128) -> Option<Self>

Converts an u128 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_f32(n: f32) -> Option<Self>

Converts a f32 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_f64(n: f64) -> Option<Self>

Converts a f64 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

impl<const MIN: i8, const MAX: i8> FromStr for BoundedI8<MIN, MAX>

type Err = ParseError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl<const MIN: i8, const MAX: i8> Hash for BoundedI8<MIN, MAX>

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<const MIN: i8, const MAX: i8> IntoBytes for BoundedI8<MIN, MAX>

where i8: IntoBytes,

fn as_bytes(&self) -> &[u8]

where Self: Immutable,

Gets the bytes of this value.

fn write_to(&self, dst: &mut [u8]) -> Result<(), SizeError<&Self, &mut [u8]>>

where Self: Immutable,

Writes a copy of self to dst.

fn write_to_prefix( &self, dst: &mut [u8], ) -> Result<(), SizeError<&Self, &mut [u8]>>

where Self: Immutable,

Writes a copy of self to the prefix of dst.

fn write_to_suffix( &self, dst: &mut [u8], ) -> Result<(), SizeError<&Self, &mut [u8]>>

where Self: Immutable,

Writes a copy of self to the suffix of dst.

impl<const MIN: i8, const MAX: i8> LowerExp for BoundedI8<MIN, MAX>

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

Formats the value using the given formatter.

impl<const MIN: i8, const MAX: i8> LowerHex for BoundedI8<MIN, MAX>

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

Formats the value using the given formatter.

impl<const MIN: i8, const MAX: i8> Mul<&BoundedI8<MIN, MAX>> for &BoundedI8<MIN, MAX>

type Output = BoundedI8<MIN, MAX>

The resulting type after applying the * operator.

fn mul(self, rhs: &BoundedI8<MIN, MAX>) -> Self::Output

Performs the * operation.

impl<const MIN: i8, const MAX: i8> Mul<&BoundedI8<MIN, MAX>> for &i8

type Output = i8

The resulting type after applying the * operator.

fn mul(self, rhs: &BoundedI8<MIN, MAX>) -> Self::Output

Performs the * operation.

impl<const MIN: i8, const MAX: i8> Mul<&BoundedI8<MIN, MAX>> for BoundedI8<MIN, MAX>

type Output = BoundedI8<MIN, MAX>

The resulting type after applying the * operator.

fn mul(self, rhs: &BoundedI8<MIN, MAX>) -> Self::Output

Performs the * operation.

impl<const MIN: i8, const MAX: i8> Mul<&BoundedI8<MIN, MAX>> for i8

type Output = i8

The resulting type after applying the * operator.

fn mul(self, rhs: &BoundedI8<MIN, MAX>) -> Self::Output

Performs the * operation.

impl<const MIN: i8, const MAX: i8> Mul<&i8> for &BoundedI8<MIN, MAX>

type Output = BoundedI8<MIN, MAX>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<const MIN: i8, const MAX: i8> Mul<&i8> for BoundedI8<MIN, MAX>

type Output = BoundedI8<MIN, MAX>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<const MIN: i8, const MAX: i8> Mul<BoundedI8<MIN, MAX>> for &BoundedI8<MIN, MAX>

type Output = BoundedI8<MIN, MAX>

The resulting type after applying the * operator.

fn mul(self, rhs: BoundedI8<MIN, MAX>) -> Self::Output

Performs the * operation.

impl<const MIN: i8, const MAX: i8> Mul<BoundedI8<MIN, MAX>> for &i8

type Output = i8

The resulting type after applying the * operator.

fn mul(self, rhs: BoundedI8<MIN, MAX>) -> Self::Output

Performs the * operation.

impl<const MIN: i8, const MAX: i8> Mul<BoundedI8<MIN, MAX>> for i8

type Output = i8

The resulting type after applying the * operator.

fn mul(self, rhs: BoundedI8<MIN, MAX>) -> Self::Output

Performs the * operation.

impl<const MIN: i8, const MAX: i8> Mul<i8> for &BoundedI8<MIN, MAX>

type Output = BoundedI8<MIN, MAX>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<const MIN: i8, const MAX: i8> Mul<i8> for BoundedI8<MIN, MAX>

type Output = BoundedI8<MIN, MAX>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<const MIN: i8, const MAX: i8> Mul for BoundedI8<MIN, MAX>

type Output = BoundedI8<MIN, MAX>

The resulting type after applying the * operator.

fn mul(self, rhs: BoundedI8<MIN, MAX>) -> Self::Output

Performs the * operation.

impl<__A, __B, const MIN: i8, const MAX: i8> MulAdd<__A, __B> for BoundedI8<MIN, MAX>

where i8: MulAdd<__A, __B, Output = i8>,

Available on crate feature num-traits02 only.

type Output = i8

The resulting type after applying the fused multiply-add.

fn mul_add(self, a: __A, b: __B) -> Self::Output

Performs the fused multiply-add operation (self * a) + b

impl<const MIN: i8, const MAX: i8> MulAssign<&BoundedI8<MIN, MAX>> for BoundedI8<MIN, MAX>

fn mul_assign(&mut self, rhs: &BoundedI8<MIN, MAX>)

Performs the *= operation.

impl<const MIN: i8, const MAX: i8> MulAssign<&BoundedI8<MIN, MAX>> for i8

fn mul_assign(&mut self, rhs: &BoundedI8<MIN, MAX>)

Performs the *= operation.

impl<const MIN: i8, const MAX: i8> MulAssign<&i8> for BoundedI8<MIN, MAX>

fn mul_assign(&mut self, rhs: &i8)

Performs the *= operation.

impl<const MIN: i8, const MAX: i8> MulAssign<BoundedI8<MIN, MAX>> for i8

fn mul_assign(&mut self, rhs: BoundedI8<MIN, MAX>)

Performs the *= operation.

impl<const MIN: i8, const MAX: i8> MulAssign<i8> for BoundedI8<MIN, MAX>

fn mul_assign(&mut self, rhs: i8)

Performs the *= operation.

impl<const MIN: i8, const MAX: i8> MulAssign for BoundedI8<MIN, MAX>

fn mul_assign(&mut self, rhs: BoundedI8<MIN, MAX>)

Performs the *= operation.

impl<const MIN: i8, const MAX: i8> Neg for &BoundedI8<MIN, MAX>

type Output = BoundedI8<MIN, MAX>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<const MIN: i8, const MAX: i8> Neg for BoundedI8<MIN, MAX>

type Output = BoundedI8<MIN, MAX>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<const MIN: i8, const MAX: i8> Not for &BoundedI8<MIN, MAX>

type Output = BoundedI8<MIN, MAX>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<const MIN: i8, const MAX: i8> Not for BoundedI8<MIN, MAX>

type Output = BoundedI8<MIN, MAX>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<const MIN: i8, const MAX: i8> NumCast for BoundedI8<MIN, MAX>

where i8: NumCast,

Available on crate feature num-traits02 only.

fn from<__T: ToPrimitive>(n: __T) -> Option<Self>

Creates a number from another value that can be converted into a primitive via the ToPrimitive trait. If the source value cannot be represented by the target type, then None is returned.

impl<const MIN: i8, const MAX: i8> Octal for BoundedI8<MIN, MAX>

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

Formats the value using the given formatter.

impl<const MIN: i8, const MAX: i8> Ord for BoundedI8<MIN, MAX>

fn cmp(&self, other: &BoundedI8<MIN, MAX>) -> 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<const MIN: i8, const MAX: i8> PartialEq<BoundedI8<MIN, MAX>> for i8

fn eq(&self, other: &BoundedI8<MIN, MAX>) -> 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<const MIN: i8, const MAX: i8> PartialEq<i8> for BoundedI8<MIN, MAX>

fn eq(&self, other: &i8) -> 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<const MIN: i8, const MAX: i8> PartialEq for BoundedI8<MIN, MAX>

fn eq(&self, other: &BoundedI8<MIN, MAX>) -> 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<const MIN: i8, const MAX: i8> PartialOrd<BoundedI8<MIN, MAX>> for i8

fn partial_cmp(&self, other: &BoundedI8<MIN, MAX>) -> 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<const MIN: i8, const MAX: i8> PartialOrd<i8> for BoundedI8<MIN, MAX>

fn partial_cmp(&self, other: &i8) -> 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<const MIN: i8, const MAX: i8> PartialOrd for BoundedI8<MIN, MAX>

fn partial_cmp(&self, other: &BoundedI8<MIN, MAX>) -> Option<Ordering>

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

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

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

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

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

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

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

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

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

impl<'__a, const MIN: i8, const MAX: i8> Product<&'__a BoundedI8<MIN, MAX>> for BoundedI8<MIN, MAX>

fn product<I: Iterator<Item = &'__a Self>>(iter: I) -> Self

Takes an iterator and generates Self from the elements by multiplying the items.

impl<'__a, const MIN: i8, const MAX: i8> Product<&'__a BoundedI8<MIN, MAX>> for i8

fn product<I: Iterator<Item = &'__a BoundedI8<MIN, MAX>>>(iter: I) -> Self

Takes an iterator and generates Self from the elements by multiplying the items.

impl<const MIN: i8, const MAX: i8> Product<BoundedI8<MIN, MAX>> for i8

fn product<I: Iterator<Item = BoundedI8<MIN, MAX>>>(iter: I) -> Self

Takes an iterator and generates Self from the elements by multiplying the items.

impl<const MIN: i8, const MAX: i8> Product for BoundedI8<MIN, MAX>

fn product<I: Iterator<Item = Self>>(iter: I) -> Self

Takes an iterator and generates Self from the elements by multiplying the items.

impl<const MIN: i8, const MAX: i8> Rem<&BoundedI8<MIN, MAX>> for &BoundedI8<MIN, MAX>

type Output = BoundedI8<MIN, MAX>

The resulting type after applying the % operator.

fn rem(self, rhs: &BoundedI8<MIN, MAX>) -> Self::Output

Performs the % operation.

impl<const MIN: i8, const MAX: i8> Rem<&BoundedI8<MIN, MAX>> for &i8

type Output = i8

The resulting type after applying the % operator.

fn rem(self, rhs: &BoundedI8<MIN, MAX>) -> Self::Output

Performs the % operation.

impl<const MIN: i8, const MAX: i8> Rem<&BoundedI8<MIN, MAX>> for BoundedI8<MIN, MAX>

type Output = BoundedI8<MIN, MAX>

The resulting type after applying the % operator.

fn rem(self, rhs: &BoundedI8<MIN, MAX>) -> Self::Output

Performs the % operation.

impl<const MIN: i8, const MAX: i8> Rem<&BoundedI8<MIN, MAX>> for i8

type Output = i8

The resulting type after applying the % operator.

fn rem(self, rhs: &BoundedI8<MIN, MAX>) -> Self::Output

Performs the % operation.

impl<const MIN: i8, const MAX: i8> Rem<&i8> for &BoundedI8<MIN, MAX>

type Output = BoundedI8<MIN, MAX>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<const MIN: i8, const MAX: i8> Rem<&i8> for BoundedI8<MIN, MAX>

type Output = BoundedI8<MIN, MAX>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<const MIN: i8, const MAX: i8> Rem<BoundedI8<MIN, MAX>> for &BoundedI8<MIN, MAX>

type Output = BoundedI8<MIN, MAX>

The resulting type after applying the % operator.

fn rem(self, rhs: BoundedI8<MIN, MAX>) -> Self::Output

Performs the % operation.

impl<const MIN: i8, const MAX: i8> Rem<BoundedI8<MIN, MAX>> for &i8

type Output = i8

The resulting type after applying the % operator.

fn rem(self, rhs: BoundedI8<MIN, MAX>) -> Self::Output

Performs the % operation.

impl<const MIN: i8, const MAX: i8> Rem<BoundedI8<MIN, MAX>> for i8

type Output = i8

The resulting type after applying the % operator.

fn rem(self, rhs: BoundedI8<MIN, MAX>) -> Self::Output

Performs the % operation.

impl<const MIN: i8, const MAX: i8> Rem<i8> for &BoundedI8<MIN, MAX>

type Output = BoundedI8<MIN, MAX>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<const MIN: i8, const MAX: i8> Rem<i8> for BoundedI8<MIN, MAX>

type Output = BoundedI8<MIN, MAX>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<const MIN: i8, const MAX: i8> Rem for BoundedI8<MIN, MAX>

type Output = BoundedI8<MIN, MAX>

The resulting type after applying the % operator.

fn rem(self, rhs: BoundedI8<MIN, MAX>) -> Self::Output

Performs the % operation.

impl<const MIN: i8, const MAX: i8> RemAssign<&BoundedI8<MIN, MAX>> for BoundedI8<MIN, MAX>

fn rem_assign(&mut self, rhs: &BoundedI8<MIN, MAX>)

Performs the %= operation.

impl<const MIN: i8, const MAX: i8> RemAssign<&BoundedI8<MIN, MAX>> for i8

fn rem_assign(&mut self, rhs: &BoundedI8<MIN, MAX>)

Performs the %= operation.

impl<const MIN: i8, const MAX: i8> RemAssign<&i8> for BoundedI8<MIN, MAX>

fn rem_assign(&mut self, rhs: &i8)

Performs the %= operation.

impl<const MIN: i8, const MAX: i8> RemAssign<BoundedI8<MIN, MAX>> for i8

fn rem_assign(&mut self, rhs: BoundedI8<MIN, MAX>)

Performs the %= operation.

impl<const MIN: i8, const MAX: i8> RemAssign<i8> for BoundedI8<MIN, MAX>

fn rem_assign(&mut self, rhs: i8)

Performs the %= operation.

impl<const MIN: i8, const MAX: i8> RemAssign for BoundedI8<MIN, MAX>

fn rem_assign(&mut self, rhs: BoundedI8<MIN, MAX>)

Performs the %= operation.

impl<const MIN: i8, const MAX: i8> SaturatingAdd for BoundedI8<MIN, MAX>

Available on crate feature num-traits02 only.

fn saturating_add(&self, v: &Self) -> Self

Saturating addition. Computes self + other, saturating at the relevant high or low boundary of the type.

impl<const MIN: i8, const MAX: i8> SaturatingMul for BoundedI8<MIN, MAX>

Available on crate feature num-traits02 only.

fn saturating_mul(&self, v: &Self) -> Self

Saturating multiplication. Computes self * other, saturating at the relevant high or low boundary of the type.

impl<const MIN: i8, const MAX: i8> SaturatingSub for BoundedI8<MIN, MAX>

Available on crate feature num-traits02 only.

fn saturating_sub(&self, v: &Self) -> Self

Saturating subtraction. Computes self - other, saturating at the relevant high or low boundary of the type.

impl<const MIN: i8, const MAX: i8> Serialize for BoundedI8<MIN, MAX>

Available on crate feature serde1 only.

fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error>

Serialize this value into the given Serde serializer.

impl<const MIN: i8, const MAX: i8> Shl<&u32> for &BoundedI8<MIN, MAX>

type Output = BoundedI8<MIN, MAX>

The resulting type after applying the << operator.

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

Performs the << operation.

impl<const MIN: i8, const MAX: i8> Shl<&u32> for BoundedI8<MIN, MAX>

type Output = BoundedI8<MIN, MAX>

The resulting type after applying the << operator.

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

Performs the << operation.

impl<const MIN: i8, const MAX: i8> Shl<u32> for &BoundedI8<MIN, MAX>

type Output = BoundedI8<MIN, MAX>

The resulting type after applying the << operator.

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

Performs the << operation.

impl<const MIN: i8, const MAX: i8> Shl<u32> for BoundedI8<MIN, MAX>

type Output = BoundedI8<MIN, MAX>

The resulting type after applying the << operator.

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

Performs the << operation.

impl<const MIN: i8, const MAX: i8> ShlAssign<&u32> for BoundedI8<MIN, MAX>

fn shl_assign(&mut self, rhs: &u32)

Performs the <<= operation.

impl<const MIN: i8, const MAX: i8> ShlAssign<u32> for BoundedI8<MIN, MAX>

fn shl_assign(&mut self, rhs: u32)

Performs the <<= operation.

impl<const MIN: i8, const MAX: i8> Shr<&u32> for &BoundedI8<MIN, MAX>

type Output = BoundedI8<MIN, MAX>

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl<const MIN: i8, const MAX: i8> Shr<&u32> for BoundedI8<MIN, MAX>

type Output = BoundedI8<MIN, MAX>

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl<const MIN: i8, const MAX: i8> Shr<u32> for &BoundedI8<MIN, MAX>

type Output = BoundedI8<MIN, MAX>

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl<const MIN: i8, const MAX: i8> Shr<u32> for BoundedI8<MIN, MAX>

type Output = BoundedI8<MIN, MAX>

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl<const MIN: i8, const MAX: i8> ShrAssign<&u32> for BoundedI8<MIN, MAX>

fn shr_assign(&mut self, rhs: &u32)

Performs the >>= operation.

impl<const MIN: i8, const MAX: i8> ShrAssign<u32> for BoundedI8<MIN, MAX>

fn shr_assign(&mut self, rhs: u32)

Performs the >>= operation.

impl<const MIN: i8, const MAX: i8> Step for BoundedI8<MIN, MAX>

Available on crate feature step_trait only.

fn steps_between(start: &Self, end: &Self) -> (usize, Option<usize>)

🔬This is a nightly-only experimental API. (step_trait)

Returns the bounds on the number of successor steps required to get from start to end like Iterator::size_hint().

fn forward_checked(start: Self, count: usize) -> Option<Self>

🔬This is a nightly-only experimental API. (step_trait)

Returns the value that would be obtained by taking the successor of self count times.

fn backward_checked(start: Self, count: usize) -> Option<Self>

🔬This is a nightly-only experimental API. (step_trait)

Returns the value that would be obtained by taking the predecessor of self count times.

fn forward(start: Self, count: usize) -> Self

🔬This is a nightly-only experimental API. (step_trait)

Returns the value that would be obtained by taking the successor of self count times.

unsafe fn forward_unchecked(start: Self, count: usize) -> Self

🔬This is a nightly-only experimental API. (step_trait)

Returns the value that would be obtained by taking the successor of self count times.

fn backward(start: Self, count: usize) -> Self

🔬This is a nightly-only experimental API. (step_trait)

Returns the value that would be obtained by taking the predecessor of self count times.

unsafe fn backward_unchecked(start: Self, count: usize) -> Self

🔬This is a nightly-only experimental API. (step_trait)

Returns the value that would be obtained by taking the predecessor of self count times.

impl<const MIN: i8, const MAX: i8> Sub<&BoundedI8<MIN, MAX>> for &BoundedI8<MIN, MAX>

type Output = BoundedI8<MIN, MAX>

The resulting type after applying the - operator.

fn sub(self, rhs: &BoundedI8<MIN, MAX>) -> Self::Output

Performs the - operation.

impl<const MIN: i8, const MAX: i8> Sub<&BoundedI8<MIN, MAX>> for &i8

type Output = i8

The resulting type after applying the - operator.

fn sub(self, rhs: &BoundedI8<MIN, MAX>) -> Self::Output

Performs the - operation.

impl<const MIN: i8, const MAX: i8> Sub<&BoundedI8<MIN, MAX>> for BoundedI8<MIN, MAX>

type Output = BoundedI8<MIN, MAX>

The resulting type after applying the - operator.

fn sub(self, rhs: &BoundedI8<MIN, MAX>) -> Self::Output

Performs the - operation.

impl<const MIN: i8, const MAX: i8> Sub<&BoundedI8<MIN, MAX>> for i8

type Output = i8

The resulting type after applying the - operator.

fn sub(self, rhs: &BoundedI8<MIN, MAX>) -> Self::Output

Performs the - operation.

impl<const MIN: i8, const MAX: i8> Sub<&i8> for &BoundedI8<MIN, MAX>

type Output = BoundedI8<MIN, MAX>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<const MIN: i8, const MAX: i8> Sub<&i8> for BoundedI8<MIN, MAX>

type Output = BoundedI8<MIN, MAX>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<const MIN: i8, const MAX: i8> Sub<BoundedI8<MIN, MAX>> for &BoundedI8<MIN, MAX>

type Output = BoundedI8<MIN, MAX>

The resulting type after applying the - operator.

fn sub(self, rhs: BoundedI8<MIN, MAX>) -> Self::Output

Performs the - operation.

impl<const MIN: i8, const MAX: i8> Sub<BoundedI8<MIN, MAX>> for &i8

type Output = i8

The resulting type after applying the - operator.

fn sub(self, rhs: BoundedI8<MIN, MAX>) -> Self::Output

Performs the - operation.

impl<const MIN: i8, const MAX: i8> Sub<BoundedI8<MIN, MAX>> for i8

type Output = i8

The resulting type after applying the - operator.

fn sub(self, rhs: BoundedI8<MIN, MAX>) -> Self::Output

Performs the - operation.

impl<const MIN: i8, const MAX: i8> Sub<i8> for &BoundedI8<MIN, MAX>

type Output = BoundedI8<MIN, MAX>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<const MIN: i8, const MAX: i8> Sub<i8> for BoundedI8<MIN, MAX>

type Output = BoundedI8<MIN, MAX>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<const MIN: i8, const MAX: i8> Sub for BoundedI8<MIN, MAX>

type Output = BoundedI8<MIN, MAX>

The resulting type after applying the - operator.

fn sub(self, rhs: BoundedI8<MIN, MAX>) -> Self::Output

Performs the - operation.

impl<const MIN: i8, const MAX: i8> SubAssign<&BoundedI8<MIN, MAX>> for BoundedI8<MIN, MAX>

fn sub_assign(&mut self, rhs: &BoundedI8<MIN, MAX>)

Performs the -= operation.

impl<const MIN: i8, const MAX: i8> SubAssign<&BoundedI8<MIN, MAX>> for i8

fn sub_assign(&mut self, rhs: &BoundedI8<MIN, MAX>)

Performs the -= operation.

impl<const MIN: i8, const MAX: i8> SubAssign<&i8> for BoundedI8<MIN, MAX>

fn sub_assign(&mut self, rhs: &i8)

Performs the -= operation.

impl<const MIN: i8, const MAX: i8> SubAssign<BoundedI8<MIN, MAX>> for i8

fn sub_assign(&mut self, rhs: BoundedI8<MIN, MAX>)

Performs the -= operation.

impl<const MIN: i8, const MAX: i8> SubAssign<i8> for BoundedI8<MIN, MAX>

fn sub_assign(&mut self, rhs: i8)

Performs the -= operation.

impl<const MIN: i8, const MAX: i8> SubAssign for BoundedI8<MIN, MAX>

fn sub_assign(&mut self, rhs: BoundedI8<MIN, MAX>)

Performs the -= operation.

impl<'__a, const MIN: i8, const MAX: i8> Sum<&'__a BoundedI8<MIN, MAX>> for BoundedI8<MIN, MAX>

fn sum<I: Iterator<Item = &'__a Self>>(iter: I) -> Self

Takes an iterator and generates Self from the elements by “summing up” the items.

impl<'__a, const MIN: i8, const MAX: i8> Sum<&'__a BoundedI8<MIN, MAX>> for i8

fn sum<I: Iterator<Item = &'__a BoundedI8<MIN, MAX>>>(iter: I) -> Self

Takes an iterator and generates Self from the elements by “summing up” the items.

impl<const MIN: i8, const MAX: i8> Sum<BoundedI8<MIN, MAX>> for i8

fn sum<I: Iterator<Item = BoundedI8<MIN, MAX>>>(iter: I) -> Self

Takes an iterator and generates Self from the elements by “summing up” the items.

impl<const MIN: i8, const MAX: i8> Sum for BoundedI8<MIN, MAX>

fn sum<I: Iterator<Item = Self>>(iter: I) -> Self

Takes an iterator and generates Self from the elements by “summing up” the items.

impl<const MIN: i8, const MAX: i8> ToPrimitive for BoundedI8<MIN, MAX>

where i8: ToPrimitive,

Available on crate feature num-traits02 only.

fn to_i64(&self) -> Option<i64>

Converts the value of self to an i64. If the value cannot be represented by an i64, then None is returned.

fn to_u64(&self) -> Option<u64>

Converts the value of self to a u64. If the value cannot be represented by a u64, then None is returned.

fn to_isize(&self) -> Option<isize>

Converts the value of self to an isize. If the value cannot be represented by an isize, then None is returned.

fn to_i8(&self) -> Option<i8>

Converts the value of self to an i8. If the value cannot be represented by an i8, then None is returned.

fn to_i16(&self) -> Option<i16>

Converts the value of self to an i16. If the value cannot be represented by an i16, then None is returned.

fn to_i32(&self) -> Option<i32>

Converts the value of self to an i32. If the value cannot be represented by an i32, then None is returned.

fn to_i128(&self) -> Option<i128>

Converts the value of self to an i128. If the value cannot be represented by an i128 (i64 under the default implementation), then None is returned.

fn to_usize(&self) -> Option<usize>

Converts the value of self to a usize. If the value cannot be represented by a usize, then None is returned.

fn to_u8(&self) -> Option<u8>

Converts the value of self to a u8. If the value cannot be represented by a u8, then None is returned.

fn to_u16(&self) -> Option<u16>

Converts the value of self to a u16. If the value cannot be represented by a u16, then None is returned.

fn to_u32(&self) -> Option<u32>

Converts the value of self to a u32. If the value cannot be represented by a u32, then None is returned.

fn to_u128(&self) -> Option<u128>

Converts the value of self to a u128. If the value cannot be represented by a u128 (u64 under the default implementation), then None is returned.

fn to_f32(&self) -> Option<f32>

Converts the value of self to an f32. Overflows may map to positive or negative inifinity, otherwise None is returned if the value cannot be represented by an f32.

fn to_f64(&self) -> Option<f64>

Converts the value of self to an f64. Overflows may map to positive or negative inifinity, otherwise None is returned if the value cannot be represented by an f64.

impl<const MIN: i8, const MAX: i8> TryFrom<BoundedI8<MIN, MAX>> for u128

type Error = TryFromIntError

The type returned in the event of a conversion error.

fn try_from(n: BoundedI8<MIN, MAX>) -> Result<Self, Self::Error>

Performs the conversion.

impl<const MIN: i8, const MAX: i8> TryFrom<BoundedI8<MIN, MAX>> for u16

type Error = TryFromIntError

The type returned in the event of a conversion error.

fn try_from(n: BoundedI8<MIN, MAX>) -> Result<Self, Self::Error>

Performs the conversion.

impl<const MIN: i8, const MAX: i8> TryFrom<BoundedI8<MIN, MAX>> for u32

type Error = TryFromIntError

The type returned in the event of a conversion error.

fn try_from(n: BoundedI8<MIN, MAX>) -> Result<Self, Self::Error>

Performs the conversion.

impl<const MIN: i8, const MAX: i8> TryFrom<BoundedI8<MIN, MAX>> for u64

type Error = TryFromIntError

The type returned in the event of a conversion error.

fn try_from(n: BoundedI8<MIN, MAX>) -> Result<Self, Self::Error>

Performs the conversion.

impl<const MIN: i8, const MAX: i8> TryFrom<BoundedI8<MIN, MAX>> for u8

type Error = TryFromIntError

The type returned in the event of a conversion error.

fn try_from(n: BoundedI8<MIN, MAX>) -> Result<Self, Self::Error>

Performs the conversion.

impl<const MIN: i8, const MAX: i8> TryFrom<BoundedI8<MIN, MAX>> for usize

type Error = TryFromIntError

The type returned in the event of a conversion error.

fn try_from(n: BoundedI8<MIN, MAX>) -> Result<Self, Self::Error>

Performs the conversion.

impl<const MIN: i8, const MAX: i8> TryFrom<i128> for BoundedI8<MIN, MAX>

type Error = TryFromError

The type returned in the event of a conversion error.

fn try_from(n: i128) -> Result<Self, Self::Error>

Performs the conversion.

impl<const MIN: i8, const MAX: i8> TryFrom<i16> for BoundedI8<MIN, MAX>

type Error = TryFromError

The type returned in the event of a conversion error.

fn try_from(n: i16) -> Result<Self, Self::Error>

Performs the conversion.

impl<const MIN: i8, const MAX: i8> TryFrom<i32> for BoundedI8<MIN, MAX>

type Error = TryFromError

The type returned in the event of a conversion error.

fn try_from(n: i32) -> Result<Self, Self::Error>

Performs the conversion.

impl<const MIN: i8, const MAX: i8> TryFrom<i64> for BoundedI8<MIN, MAX>

type Error = TryFromError

The type returned in the event of a conversion error.

fn try_from(n: i64) -> Result<Self, Self::Error>

Performs the conversion.

impl<const MIN: i8, const MAX: i8> TryFrom<i8> for BoundedI8<MIN, MAX>

type Error = TryFromError

The type returned in the event of a conversion error.

fn try_from(n: i8) -> Result<Self, Self::Error>

Performs the conversion.

impl<const MIN: i8, const MAX: i8> TryFrom<isize> for BoundedI8<MIN, MAX>

type Error = TryFromError

The type returned in the event of a conversion error.

fn try_from(n: isize) -> Result<Self, Self::Error>

Performs the conversion.

impl<const MIN: i8, const MAX: i8> TryFrom<u128> for BoundedI8<MIN, MAX>

type Error = TryFromError

The type returned in the event of a conversion error.

fn try_from(n: u128) -> Result<Self, Self::Error>

Performs the conversion.

impl<const MIN: i8, const MAX: i8> TryFrom<u16> for BoundedI8<MIN, MAX>

type Error = TryFromError

The type returned in the event of a conversion error.

fn try_from(n: u16) -> Result<Self, Self::Error>

Performs the conversion.

impl<const MIN: i8, const MAX: i8> TryFrom<u32> for BoundedI8<MIN, MAX>

type Error = TryFromError

The type returned in the event of a conversion error.

fn try_from(n: u32) -> Result<Self, Self::Error>

Performs the conversion.

impl<const MIN: i8, const MAX: i8> TryFrom<u64> for BoundedI8<MIN, MAX>

type Error = TryFromError

The type returned in the event of a conversion error.

fn try_from(n: u64) -> Result<Self, Self::Error>

Performs the conversion.

impl<const MIN: i8, const MAX: i8> TryFrom<u8> for BoundedI8<MIN, MAX>

type Error = TryFromError

The type returned in the event of a conversion error.

fn try_from(n: u8) -> Result<Self, Self::Error>

Performs the conversion.

impl<const MIN: i8, const MAX: i8> TryFrom<usize> for BoundedI8<MIN, MAX>

type Error = TryFromError

The type returned in the event of a conversion error.

fn try_from(n: usize) -> Result<Self, Self::Error>

Performs the conversion.

impl<const MIN: i8, const MAX: i8> UpperExp for BoundedI8<MIN, MAX>

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

Formats the value using the given formatter.

impl<const MIN: i8, const MAX: i8> UpperHex for BoundedI8<MIN, MAX>

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

Formats the value using the given formatter.

impl<const MAX: i8> Zeroable for BoundedI8<0, MAX>

Available nowhere.

fn zeroed() -> Self

Calls zeroed.

impl<const MIN: i8, const MAX: i8> Copy for BoundedI8<MIN, MAX>

impl<const MIN: i8, const MAX: i8> Eq for BoundedI8<MIN, MAX>

impl<const MIN: i8, const MAX: i8> Immutable for BoundedI8<MIN, MAX>

where i8: Immutable,

impl<const MIN: i8, const MAX: i8> NoUninit for BoundedI8<MIN, MAX>

where Self: 'static,

Available on crate feature bytemuck1 only.

impl<const MIN: i8, const MAX: i8> Unaligned for BoundedI8<MIN, MAX>

where i8: Unaligned,