Struct deranged::RangedI8

#[repr(transparent)]
pub struct RangedI8<const MIN: i8, const MAX: i8>(pub(crate) Unsafe<i8>);

An i8 that is known to be in the range MIN..=MAX.

Tuple Fields

0: Unsafe<i8>

Implementations

impl RangedI8<0, 0>

pub const fn exact<const VALUE: i8>() -> RangedI8<VALUE, VALUE>

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

pub const MIN: Self = _

The smallest value that can be represented by this type.

pub const MAX: Self = _

The largest value that can be represented by this type.

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

Creates a ranged integer without checking the value.

Safety

The value must be within the range MIN..=MAX.

pub const fn get(self) -> i8

Returns the value as a primitive type.

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

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

Creates a ranged integer if the given value is in the range MIN..=MAX.

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

Creates a ranged integer with a statically known value. Fails to compile if the value is not in range.

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

Creates a ranged integer with the given value, saturating if it is out of range.

pub const fn expand<const NEW_MIN: i8, const NEW_MAX: i8>( self, ) -> RangedI8<NEW_MIN, NEW_MAX>

Expand the range that the value may be in. Fails to compile if the new range is not a superset of the current range.

pub const fn narrow<const NEW_MIN: i8, const NEW_MAX: i8>( self, ) -> Option<RangedI8<NEW_MIN, NEW_MAX>>

Attempt to narrow the range that the value may be in. Returns None if the value is outside the new range. Fails to compile if the new range is not a subset of the current range.

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

Converts a string slice in a given base to an integer.

The string is expected to be an optional + or - sign followed by digits. Leading and trailing whitespace represent an error. Digits are a subset of these characters, depending on radix:

• 0-9
• a-z
• A-Z

Panics

Panics if radix is not in the range 2..=36.

Examples

Basic usage:

assert_eq!(RangedI8::<5, 10>::from_str_radix("A", 16), Ok(RangedI8::new_static::<10>()));

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

Checked integer addition. Computes self + rhs, returning None if the resulting value is out of range.

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

Unchecked integer addition. Computes self + rhs, assuming that the result is in range.

Safety

The result of self + rhs must be in the range MIN..=MAX.

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

Checked integer addition. Computes self - rhs, returning None if the resulting value is out of range.

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

Unchecked integer subtraction. Computes self - rhs, assuming that the result is in range.

Safety

The result of self - rhs must be in the range MIN..=MAX.

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

Checked integer addition. Computes self * rhs, returning None if the resulting value is out of range.

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

Unchecked integer multiplication. Computes self * rhs, assuming that the result is in range.

Safety

The result of self * rhs must be in the range MIN..=MAX.

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

Checked integer addition. Computes self / rhs, returning None if rhs == 0 or if the resulting value is out of range.

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

Unchecked integer division. Computes self / rhs, assuming that rhs != 0 and that the result is in range.

Safety

self must not be zero and the result of self / rhs must be in the range MIN..=MAX.

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

Checked Euclidean division. Computes self.div_euclid(rhs), returning None if rhs == 0 or if the resulting value is out of range.

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

Unchecked Euclidean division. Computes self.div_euclid(rhs), assuming that rhs != 0 and that the result is in range.

Safety

self must not be zero and the result of self.div_euclid(rhs) must be in the range MIN..=MAX.

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

Checked integer remainder. Computes self % rhs, returning None if rhs == 0 or if the resulting value is out of range.

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

Unchecked remainder. Computes self % rhs, assuming that rhs != 0 and that the result is in range.

Safety

self must not be zero and the result of self % rhs must be in the range MIN..=MAX.

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

Checked Euclidean remainder. Computes self.rem_euclid(rhs), returning None if rhs == 0 or if the resulting value is out of range.

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

Unchecked Euclidean remainder. Computes self.rem_euclid(rhs), assuming that rhs != 0 and that the result is in range.

Safety

self must not be zero and the result of self.rem_euclid(rhs) must be in the range MIN..=MAX.

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

Checked negation. Computes -self, returning None if the resulting value is out of range.

pub const unsafe fn unchecked_neg(self) -> Self

Unchecked negation. Computes -self, assuming that -self is in range.

Safety

The result of -self must be in the range MIN..=MAX.

pub const fn neg(self) -> Self

Negation. Computes self.neg(), failing to compile if the result is not guaranteed to be in range.

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

Checked shift left. Computes self << rhs, returning None if the resulting value is out of range.

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

Unchecked shift left. Computes self << rhs, assuming that the result is in range.

Safety

The result of self << rhs must be in the range MIN..=MAX.

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

Checked shift right. Computes self >> rhs, returning None if the resulting value is out of range.

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

Unchecked shift right. Computes self >> rhs, assuming that the result is in range.

Safety

The result of self >> rhs must be in the range MIN..=MAX.

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

Checked absolute value. Computes self.abs(), returning None if the resulting value is out of range.

pub const unsafe fn unchecked_abs(self) -> Self

Unchecked absolute value. Computes self.abs(), assuming that the result is in range.

Safety

The result of self.abs() must be in the range MIN..=MAX.

pub const fn abs(self) -> Self

Absolute value. Computes self.abs(), failing to compile if the result is not guaranteed to be in range.

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

Checked exponentiation. Computes self.pow(exp), returning None if the resulting value is out of range.

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

Unchecked exponentiation. Computes self.pow(exp), assuming that the result is in range.

Safety

The result of self.pow(exp) must be in the range MIN..=MAX.

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

Saturating integer addition. Computes self + rhs, saturating at the numeric bounds.

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

Saturating integer subtraction. Computes self - rhs, saturating at the numeric bounds.

pub const fn saturating_neg(self) -> Self

Saturating integer negation. Computes self - rhs, saturating at the numeric bounds.

pub const fn saturating_abs(self) -> Self

Saturating absolute value. Computes self.abs(), saturating at the numeric bounds.

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

Saturating integer multiplication. Computes self * rhs, saturating at the numeric bounds.

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

Saturating integer exponentiation. Computes self.pow(exp), saturating at the numeric bounds.

pub(crate) const fn rem_euclid_unsigned(rhs: i8, range_len: u8) -> u8

Compute the rem_euclid of this type with its unsigned type equivalent

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

Wrapping integer addition. Computes self + rhs, wrapping around the numeric bounds.

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

Wrapping integer subtraction. Computes self - rhs, wrapping around the numeric bounds.

Trait Implementations

impl<const MIN: i8, const MAX: i8> AbsIsSafe for RangedI8<MIN, MAX>

const ASSERT: () = _

impl<const MIN: i8, const MAX: i8> AsRef<i8> for RangedI8<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 RangedI8<MIN, MAX>

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

Formats the value using the given formatter.

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

fn borrow(&self) -> &i8

Immutably borrows from an owned value.

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

fn clone(&self) -> RangedI8<MIN, MAX>

Returns a copy of the value.

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

Performs copy-assignment from source.

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

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

Formats the value using the given formatter.

impl<'de, const MIN: i8, const MAX: i8> Deserialize<'de> for RangedI8<MIN, MAX>

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 RangedI8<MIN, MAX>

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

Formats the value using the given formatter.

impl<const MIN: i8, const MAX: i8> From<RangedI8<MIN, MAX>> for OptionRangedI8<MIN, MAX>

fn from(value: RangedI8<MIN, MAX>) -> Self

Converts to this type from the input type.

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

fn from(value: RangedI8<MIN, MAX>) -> Self

Converts to this type from the input type.

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

type Err = ParseIntError

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 RangedI8<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> LowerExp for RangedI8<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 RangedI8<MIN, MAX>

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

Formats the value using the given formatter.

impl<const MIN: i8, const MAX: i8> NegIsSafe for RangedI8<MIN, MAX>

const ASSERT: () = _

impl<const MIN: i8, const MAX: i8> Octal for RangedI8<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 RangedI8<MIN, MAX>

fn cmp(&self, other: &RangedI8<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 + PartialOrd,

Restrict a value to a certain interval.

impl<const MIN_A: i8, const MAX_A: i8, const MIN_B: i8, const MAX_B: i8> PartialEq<RangedI8<MIN_B, MAX_B>> for RangedI8<MIN_A, MAX_A>

fn eq(&self, other: &RangedI8<MIN_B, MAX_B>) -> 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_A: i8, const MAX_A: i8, const MIN_B: i8, const MAX_B: i8> PartialOrd<RangedI8<MIN_B, MAX_B>> for RangedI8<MIN_A, MAX_A>

fn partial_cmp(&self, other: &RangedI8<MIN_B, MAX_B>) -> 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> RangeIsValid for RangedI8<MIN, MAX>

const ASSERT: () = _

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

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> SmartDisplay for RangedI8<MIN, MAX>

type Metadata = <i8 as SmartDisplay>::Metadata

User-provided metadata type.

fn metadata(&self, f: FormatterOptions) -> Metadata<'_, Self>

Compute any information needed to format the value. This must, at a minimum, determine the width of the value before any padding is added by the formatter.

fn fmt_with_metadata( &self, f: &mut Formatter<'_>, metadata: Metadata<'_, Self>, ) -> Result

Format the value using the given formatter and metadata. The formatted output should have the width indicated by the metadata. This is before any padding is added by the formatter.

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

Format the value using the given formatter. This is the same as Display::fmt.

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

type Error = TryFromIntError

The type returned in the event of a conversion error.

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

Performs the conversion.

impl<const MIN: i8, const MAX: i8> UpperExp for RangedI8<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 RangedI8<MIN, MAX>

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

Formats the value using the given formatter.

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

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