/rust/registry/src/index.crates.io-6f17d22bba15001f/funty-2.0.0/src/lib.rs

Source (jump to first uncovered line)
/*! `fun`damental `ty`pes

This crate provides trait unification of the Rust fundamental items, allowing
users to declare the behavior they want from a number without committing to a
single particular numeric type.

The number types can be categorized along two axes: behavior and width. Traits
for each axis and group on that axis are provided:

## Numeric Categories

The most general category is represented by the trait [`Numeric`]. It is
implemented by all the numeric fundamentals, and includes only the traits that
they all implement. This is an already-large amount: basic memory management,
comparison, rendering, and numeric arithmetic.

The numbers are then split into [`Floating`] and [`Integral`]. The former fills
out the API of `f32` and `f64`, while the latter covers all of the `iN` and `uN`
numbers.

Lastly, [`Integral`] splits further, into [`Signed`] and [`Unsigned`]. These
provide the last specializations unique to the differences between `iN` and
`uN`.

## Width Categories

Every number implements the trait `IsN` for the `N` of its bit width. `isize`
and `usize` implement the trait that matches their width on the target platform.

In addition, the trait groups `AtLeastN` and `AtMostN` enable clamping the range
of acceptable widths to lower or upper bounds. These traits are equivalent to
`mem::size_of::<T>() >= N` and `mem::size_of::<T>() <= N`, respectively.

[`Floating`]: trait.Floating.html
[`Integral`]: trait.Integral.html
[`Numeric`]: trait.Numeric.html
[`Signed`]: trait.Signed.html
[`Unsigned`]: trait.Unsigned.html
!*/

#![cfg_attr(not(feature = "std"), no_std)]
#![deny(unconditional_recursion)]

use core::{
  convert::{
    TryFrom,
    TryInto,
  },
  fmt::{
    Binary,
    Debug,
    Display,
    LowerExp,
    LowerHex,
    Octal,
    UpperExp,
    UpperHex,
  },
  hash::Hash,
  iter::{
    Product,
    Sum,
  },
  num::{
    FpCategory,
    ParseIntError,
  },
  ops::{
    Add,
    AddAssign,
    BitAnd,
    BitAndAssign,
    BitOr,
    BitOrAssign,
    BitXor,
    BitXorAssign,
    Div,
    DivAssign,
    Mul,
    MulAssign,
    Neg,
    Not,
    Rem,
    RemAssign,
    Shl,
    ShlAssign,
    Shr,
    ShrAssign,
    Sub,
    SubAssign,
  },
  str::FromStr,
};

/// Declare that a type is one of the language fundamental types.
pub trait Fundamental:
  'static
  + Sized
  + Send
  + Sync
  + Unpin
  + Clone
  + Copy
  + Default
  + FromStr
  //  cmp
  + PartialEq<Self>
  + PartialOrd<Self>
  //  fmt
  + Debug
  + Display
  {
    /// Tests `self != 0`.
    fn as_bool(self) -> bool;

    /// Represents `self` as a Unicode Scalar Value, if possible.
    fn as_char(self) -> Option<char>;

    /// Performs `self as i8`.
    fn as_i8(self) -> i8;

    /// Performs `self as i16`.
    fn as_i16(self) -> i16;

    /// Performs `self as i32`.
    fn as_i32(self) -> i32;

    /// Performs `self as i64`.
    fn as_i64(self) -> i64;

    /// Performs `self as i128`.
    fn as_i128(self) -> i128;

    /// Performs `self as isize`.
    fn as_isize(self) -> isize;

    /// Performs `self as u8`.
    fn as_u8(self) -> u8;

    /// Performs `self as u16`.
    fn as_u16(self) -> u16;

    /// Performs `self as u32`.
    fn as_u32(self) -> u32;

    /// Performs `self as u64`.
    fn as_u64(self) -> u64;

    /// Performs `self as u128`.
    fn as_u128(self) -> u128;

    /// Performs `self as usize`.
    fn as_usize(self) -> usize;

    /// Performs `self as f32`.
    fn as_f32(self) -> f32;

    /// Performs `self as f64`.
    fn as_f64(self) -> f64;
  }

/// Declare that a type is an abstract number.
///
/// This unifies all of the signed-integer, unsigned-integer, and floating-point
/// types.
pub trait Numeric:
  Fundamental
  //  iter
  + Product<Self>
  + for<'a> Product<&'a Self>
  + Sum<Self>
  + for<'a> Sum<&'a Self>
  //  numeric ops
  + Add<Self, Output = Self>
  + for<'a> Add<&'a Self, Output = Self>
  + AddAssign<Self>
  + for<'a> AddAssign<&'a Self>
  + Sub<Self, Output = Self>
  + for<'a> Sub<&'a Self, Output = Self>
  + SubAssign<Self>
  + for<'a> SubAssign<&'a Self>
  + Mul<Self, Output = Self>
  + for<'a> Mul<&'a Self, Output = Self>
  + MulAssign<Self>
  + for<'a> MulAssign<&'a Self>
  + Div<Self, Output = Self>
  + for<'a> Div<&'a Self, Output = Self>
  + DivAssign<Self>
  + for<'a> DivAssign<&'a Self>
  + Rem<Self, Output = Self>
  + for<'a> Rem<&'a Self, Output = Self>
  + RemAssign<Self>
  + for<'a> RemAssign<&'a Self>
{
  /// The `[u8; N]` byte array that stores values of `Self`.
  type Bytes;

  /// Return the memory representation of this number as a byte array in
  /// big-endian (network) byte order.
  fn to_be_bytes(self) -> Self::Bytes;

  /// Return the memory representation of this number as a byte array in
  /// little-endian byte order.
  fn to_le_bytes(self) -> Self::Bytes;

  /// Return the memory representation of this number as a byte array in
  /// native byte order.
  fn to_ne_bytes(self) -> Self::Bytes;

  /// Create a numeric value from its representation as a byte array in big
  /// endian.
  fn from_be_bytes(bytes: Self::Bytes) -> Self;

  /// Create a numeric value from its representation as a byte array in little
  /// endian.
  fn from_le_bytes(bytes: Self::Bytes) -> Self;

  /// Create a numeric value from its memory representation as a byte array in
  /// native endianness.
  fn from_ne_bytes(bytes: Self::Bytes) -> Self;
}

/// Declare that a type is a fixed-point integer.
///
/// This unifies all of the signed and unsigned integral types.
pub trait Integral:
  Numeric
  + Hash
  + Eq
  + Ord
  + Binary
  + LowerHex
  + UpperHex
  + Octal
  + BitAnd<Self, Output = Self>
  + for<'a> BitAnd<&'a Self, Output = Self>
  + BitAndAssign<Self>
  + for<'a> BitAndAssign<&'a Self>
  + BitOr<Self, Output = Self>
  + for<'a> BitOr<&'a Self, Output = Self>
  + BitOrAssign<Self>
  + for<'a> BitOrAssign<&'a Self>
  + BitXor<Self, Output = Self>
  + for<'a> BitXor<&'a Self, Output = Self>
  + BitXorAssign<Self>
  + for<'a> BitXorAssign<&'a Self>
  + Not<Output = Self>
  + TryFrom<i8>
  + TryFrom<u8>
  + TryFrom<i16>
  + TryFrom<u16>
  + TryFrom<i32>
  + TryFrom<u32>
  + TryFrom<i64>
  + TryFrom<u64>
  + TryFrom<i128>
  + TryFrom<u128>
  + TryFrom<isize>
  + TryFrom<usize>
  + TryInto<i8>
  + TryInto<u8>
  + TryInto<i16>
  + TryInto<u16>
  + TryInto<i32>
  + TryInto<u32>
  + TryInto<i64>
  + TryInto<u64>
  + TryInto<i128>
  + TryInto<u128>
  + TryInto<isize>
  + TryInto<usize>
  + Shl<Self, Output = Self>
  + for<'a> Shl<&'a Self, Output = Self>
  + ShlAssign<Self>
  + for<'a> ShlAssign<&'a Self>
  + Shr<Self, Output = Self>
  + for<'a> Shr<&'a Self, Output = Self>
  + ShrAssign<Self>
  + for<'a> ShrAssign<&'a Self>
  + Shl<i8, Output = Self>
  + for<'a> Shl<&'a i8, Output = Self>
  + ShlAssign<i8>
  + for<'a> ShlAssign<&'a i8>
  + Shr<i8, Output = Self>
  + for<'a> Shr<&'a i8, Output = Self>
  + ShrAssign<i8>
  + for<'a> ShrAssign<&'a i8>
  + Shl<u8, Output = Self>
  + for<'a> Shl<&'a u8, Output = Self>
  + ShlAssign<u8>
  + for<'a> ShlAssign<&'a u8>
  + Shr<u8, Output = Self>
  + for<'a> Shr<&'a u8, Output = Self>
  + ShrAssign<u8>
  + for<'a> ShrAssign<&'a u8>
  + Shl<i16, Output = Self>
  + for<'a> Shl<&'a i16, Output = Self>
  + ShlAssign<i16>
  + for<'a> ShlAssign<&'a i16>
  + Shr<i16, Output = Self>
  + for<'a> Shr<&'a i16, Output = Self>
  + ShrAssign<i16>
  + for<'a> ShrAssign<&'a i16>
  + Shl<u16, Output = Self>
  + for<'a> Shl<&'a u16, Output = Self>
  + ShlAssign<u16>
  + for<'a> ShlAssign<&'a u16>
  + Shr<u16, Output = Self>
  + for<'a> Shr<&'a u16, Output = Self>
  + ShrAssign<u16>
  + for<'a> ShrAssign<&'a u16>
  + Shl<i32, Output = Self>
  + for<'a> Shl<&'a i32, Output = Self>
  + ShlAssign<i32>
  + for<'a> ShlAssign<&'a i32>
  + Shr<i32, Output = Self>
  + for<'a> Shr<&'a i32, Output = Self>
  + ShrAssign<i32>
  + for<'a> ShrAssign<&'a i32>
  + Shl<u32, Output = Self>
  + for<'a> Shl<&'a u32, Output = Self>
  + ShlAssign<u32>
  + for<'a> ShlAssign<&'a u32>
  + Shr<u32, Output = Self>
  + for<'a> Shr<&'a u32, Output = Self>
  + ShrAssign<u32>
  + for<'a> ShrAssign<&'a u32>
  + Shl<i64, Output = Self>
  + for<'a> Shl<&'a i64, Output = Self>
  + ShlAssign<i64>
  + for<'a> ShlAssign<&'a i64>
  + Shr<i64, Output = Self>
  + for<'a> Shr<&'a i64, Output = Self>
  + ShrAssign<i64>
  + for<'a> ShrAssign<&'a i64>
  + Shl<u64, Output = Self>
  + for<'a> Shl<&'a u64, Output = Self>
  + ShlAssign<u64>
  + for<'a> ShlAssign<&'a u64>
  + Shr<u64, Output = Self>
  + for<'a> Shr<&'a u64, Output = Self>
  + ShrAssign<u64>
  + for<'a> ShrAssign<&'a u64>
  + Shl<i128, Output = Self>
  + for<'a> Shl<&'a i128, Output = Self>
  + ShlAssign<i128>
  + for<'a> ShlAssign<&'a i128>
  + Shr<i128, Output = Self>
  + for<'a> Shr<&'a i128, Output = Self>
  + ShrAssign<i128>
  + for<'a> ShrAssign<&'a i128>
  + Shl<u128, Output = Self>
  + for<'a> Shl<&'a u128, Output = Self>
  + ShlAssign<u128>
  + for<'a> ShlAssign<&'a u128>
  + Shr<u128, Output = Self>
  + for<'a> Shr<&'a u128, Output = Self>
  + ShrAssign<u128>
  + for<'a> ShrAssign<&'a u128>
  + Shl<isize, Output = Self>
  + for<'a> Shl<&'a isize, Output = Self>
  + ShlAssign<isize>
  + for<'a> ShlAssign<&'a isize>
  + Shr<isize, Output = Self>
  + for<'a> Shr<&'a isize, Output = Self>
  + ShrAssign<isize>
  + for<'a> ShrAssign<&'a isize>
  + Shl<usize, Output = Self>
  + for<'a> Shl<&'a usize, Output = Self>
  + ShlAssign<usize>
  + for<'a> ShlAssign<&'a usize>
  + Shr<usize, Output = Self>
  + for<'a> Shr<&'a usize, Output = Self>
  + ShrAssign<usize>
  + for<'a> ShrAssign<&'a usize>
{
  /// The type’s zero value.
  const ZERO: Self;

  /// The type’s step value.
  const ONE: Self;

  /// The type’s minimum value. This is zero for unsigned integers.
  const MIN: Self;

  /// The type’s maximum value.
  const MAX: Self;

  /// The size of this type in bits.
  const BITS: u32;

  /// Returns the smallest value that can be represented by this integer type.
  fn min_value() -> Self;

  /// Returns the largest value that can be represented by this integer type.
  fn max_value() -> Self;

  /// 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
  ///
  /// This function panics if `radix` is not in the range from 2 to 36.
  fn from_str_radix(src: &str, radix: u32) -> Result<Self, ParseIntError>;

  /// Returns the number of ones in the binary representation of `self`.
  fn count_ones(self) -> u32;

  /// Returns the number of zeros in the binary representation of `self`.
  fn count_zeros(self) -> u32;

  /// Returns the number of leading zeros in the binary representation of
  /// `self`.
  fn leading_zeros(self) -> u32;

  /// Returns the number of trailing zeros in the binary representation of
  /// `self`.
  fn trailing_zeros(self) -> u32;

  /// Returns the number of leading ones in the binary representation of
  /// `self`.
  fn leading_ones(self) -> u32;

  /// Returns the number of trailing ones in the binary representation of
  /// `self`.
  fn trailing_ones(self) -> u32;

  /// Shifts the bits to the left by a specified amount, `n`, wrapping the
  /// truncated bits to the end of the resulting integer.
  ///
  /// Please note this isn’t the same operation as the `<<` shifting operator!
  fn rotate_left(self, n: u32) -> Self;

  /// Shifts the bits to the right by a specified amount, `n`, wrapping the
  /// truncated bits to the beginning of the resulting integer.
  ///
  /// Please note this isn’t the same operation as the `>>` shifting operator!
  fn rotate_right(self, n: u32) -> Self;

  /// Reverses the byte order of the integer.
  fn swap_bytes(self) -> Self;

  /// Reverses the bit pattern of the integer.
  fn reverse_bits(self) -> Self;

  /// Converts an integer from big endian to the target’s endianness.
  ///
  /// On big endian this is a no-op. On little endian the bytes are swapped.
  #[allow(clippy::wrong_self_convention)]
  fn from_be(self) -> Self;

  /// Converts an integer frm little endian to the target’s endianness.
  ///
  /// On little endian this is a no-op. On big endian the bytes are swapped.
  #[allow(clippy::wrong_self_convention)]
  fn from_le(self) -> Self;

  /// Converts `self` to big endian from the target’s endianness.
  ///
  /// On big endian this is a no-op. On little endian the bytes are swapped.
  fn to_be(self) -> Self;

  /// Converts `self` to little endian from the target’s endianness.
  ///
  /// On little endian this is a no-op. On big endian the bytes are swapped.
  fn to_le(self) -> Self;

  /// Checked integer addition. Computes `self + rhs`, returning `None` if
  /// overflow occurred.
  fn checked_add(self, rhs: Self) -> Option<Self>;

  /// Checked integer subtraction. Computes `self - rhs`, returning `None` if
  /// overflow occurred.
  fn checked_sub(self, rhs: Self) -> Option<Self>;

  /// Checked integer multiplication. Computes `self * rhs`, returning `None`
  /// if overflow occurred.
  fn checked_mul(self, rhs: Self) -> Option<Self>;

  /// Checked integer division. Computes `self / rhs`, returning `None` if
  /// `rhs == 0` or the division results in overflow.
  fn checked_div(self, rhs: Self) -> Option<Self>;

  /// Checked Euclidean division. Computes `self.div_euclid(rhs)`, returning
  /// `None` if `rhs == 0` or the division results in overflow.
  fn checked_div_euclid(self, rhs: Self) -> Option<Self>;

  /// Checked integer remainder. Computes `self % rhs`, returning `None` if
  /// `rhs == 0` or the division results in overflow.
  fn checked_rem(self, rhs: Self) -> Option<Self>;

  /// Checked Euclidean remainder. Computes `self.rem_euclid(rhs)`, returning
  /// `None` if `rhs == 0` or the division results in overflow.
  fn checked_rem_euclid(self, rhs: Self) -> Option<Self>;

  /// Checked negation. Computes `-self`, returning `None` if `self == MIN`.
  ///
  /// Note that negating any positive integer will overflow.
  fn checked_neg(self) -> Option<Self>;

  /// Checked shift left. Computes `self << rhs`, returning `None` if `rhs` is
  /// larger than or equal to the number of bits in `self`.
  fn checked_shl(self, rhs: 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`.
  fn checked_shr(self, rhs: u32) -> Option<Self>;

  /// Checked exponentiation. Computes `self.pow(exp)`, returning `None` if
  /// overflow occurred.
  fn checked_pow(self, rhs: u32) -> Option<Self>;

  /// Saturating integer addition. Computes `self + rhs`, saturating at the
  /// numeric bounds instead of overflowing.
  fn saturating_add(self, rhs: Self) -> Self;

  /// Saturating integer subtraction. Computes `self - rhs`, saturating at the
  /// numeric bounds instead of overflowing.
  fn saturating_sub(self, rhs: Self) -> Self;

  /// Saturating integer multiplication. Computes `self * rhs`, saturating at
  /// the numeric bounds instead of overflowing.
  fn saturating_mul(self, rhs: Self) -> Self;

  /// Saturating integer exponentiation. Computes `self.pow(exp)`, saturating
  /// at the numeric bounds instead of overflowing.
  fn saturating_pow(self, rhs: u32) -> Self;

  /// Wrapping (modular) addition. Computes `self + rhs`, wrapping around at
  /// the boundary of the type.
  fn wrapping_add(self, rhs: Self) -> Self;

  /// Wrapping (modular) subtraction. Computes `self - rhs`, wrapping around
  /// at the boundary of the type.
  fn wrapping_sub(self, rhs: Self) -> Self;

  /// Wrapping (modular) multiplication. Computes `self * rhs`, wrapping
  /// around at the boundary of the type.
  fn wrapping_mul(self, rhs: Self) -> Self;

  /// Wrapping (modular) division. Computes `self / rhs`, wrapping around at
  /// the boundary of the type.
  ///
  /// # Signed Integers
  ///
  /// The only case where such wrapping can occur is when one divides
  /// `MIN / -1` on a signed type (where `MIN` is the negative minimal value
  /// for the type); this is equivalent to `-MIN`, a positive value that is
  /// too large to represent in the type. In such a case, this function
  /// returns `MIN` itself.
  ///
  /// # Unsigned Integers
  ///
  /// Wrapping (modular) division. Computes `self / rhs`. Wrapped division on
  /// unsigned types is just normal division. There’s no way wrapping could
  /// ever happen. This function exists, so that all operations are accounted
  /// for in the wrapping operations.
  ///
  /// # Panics
  ///
  /// This function will panic if `rhs` is 0.
  fn wrapping_div(self, rhs: Self) -> Self;

  /// Wrapping Euclidean division. Computes `self.div_euclid(rhs)`, wrapping
  /// around at the boundary of the type.
  ///
  /// # Signed Types
  ///
  /// Wrapping will only occur in `MIN / -1` on a signed type (where `MIN` is
  /// the negative minimal value for the type). This is equivalent to `-MIN`,
  /// a positive value that is too large to represent in the type. In this
  /// case, this method returns `MIN` itself.
  ///
  /// # Unsigned Types
  ///
  /// Wrapped division on unsigned types is just normal division. There’s no
  /// way wrapping could ever happen. This function exists, so that all
  /// operations are accounted for in the wrapping operations. Since, for the
  /// positive integers, all common definitions of division are equal, this is
  /// exactly equal to `self.wrapping_div(rhs)`.
  ///
  /// # Panics
  ///
  /// This function will panic if `rhs` is 0.
  fn wrapping_div_euclid(self, rhs: Self) -> Self;

  /// Wrapping (modular) remainder. Computes `self % rhs`, wrapping around at
  /// the boundary of the type.
  ///
  /// # Signed Integers
  ///
  /// Such wrap-around never actually occurs mathematically; implementation
  /// artifacts make `x % y` invalid for `MIN / -1` on a signed type (where
  /// `MIN` is the negative minimal value). In such a case, this function
  /// returns `0`.
  ///
  /// # Unsigned Integers
  ///
  /// Wrapped remainder calculation on unsigned types is just the regular
  /// remainder calculation. There’s no way wrapping could ever happen. This
  /// function exists, so that all operations are accounted for in the
  /// wrapping operations.
  ///
  /// # Panics
  ///
  /// This function will panic if `rhs` is 0.
  fn wrapping_rem(self, rhs: Self) -> Self;

  /// Wrapping Euclidean remainder. Computes `self.rem_euclid(rhs)`, wrapping
  /// around at the boundary of the type.
  ///
  /// # Signed Integers
  ///
  /// Wrapping will only occur in `MIN % -1` on a signed type (where `MIN` is
  /// the negative minimal value for the type). In this case, this method
  /// returns 0.
  ///
  /// # Unsigned Integers
  ///
  /// Wrapped modulo calculation on unsigned types is just the regular
  /// remainder calculation. There’s no way wrapping could ever happen. This
  /// function exists, so that all operations are accounted for in the
  /// wrapping operations. Since, for the positive integers, all common
  /// definitions of division are equal, this is exactly equal to
  /// `self.wrapping_rem(rhs)`.
  ///
  /// # Panics
  ///
  /// This function will panic if `rhs` is 0.
  fn wrapping_rem_euclid(self, rhs: Self) -> Self;

  /// Wrapping (modular) negation. Computes `-self`, wrapping around at the
  /// boundary of the type.
  ///
  /// # Signed Integers
  ///
  /// The  only case where such wrapping can occur is when one negates `MIN`
  /// on a signed type (where `MIN` is the negative minimal value for the
  /// type); this is a positive value that is too large to represent in the
  /// type. In such a case, this function returns `MIN` itself.
  ///
  /// # Unsigned Integers
  ///
  /// Since unsigned types do not have negative equivalents all applications
  /// of this function will wrap (except for `-0`). For values smaller than
  /// the corresponding signed type’s maximum the result is the same as
  /// casting the corresponding signed value. Any larger values are equivalent
  /// to `MAX + 1 - (val - MAX - 1)` where `MAX` is the corresponding signed
  /// type’s maximum.
  fn wrapping_neg(self) -> Self;

  /// Panic-free bitwise shift-left; yields `self << mask(rhs)`, where `mask`
  /// removes any high-order bits of `rhs` that would cause the shift to
  /// exceed the bit-width of the type.
  ///
  /// Note that this is not the same as a rotate-left; the RHS of a wrapping
  /// shift-left is restricted to the range of the type, rather than the bits
  /// shifted out of the LHS being returned to the other end. The primitive
  /// integer types all implement a `rotate_left` function, which may be what
  /// you want instead.
  fn wrapping_shl(self, rhs: u32) -> Self;

  /// Panic-free bitwise shift-right; yields `self >> mask(rhs)`, where `mask`
  /// removes any high-order bits of `rhs` that would cause the shift to
  /// exceed the bit-width of the type.
  ///
  /// Note that this is not the same as a rotate-right; the RHS of a wrapping
  /// shift-right is restricted to the range of the type, rather than the bits
  /// shifted out of the LHS being returned to the other end. The primitive
  /// integer types all implement a `rotate_right` function, which may be what
  /// you want instead.
  fn wrapping_shr(self, rhs: u32) -> Self;

  /// Wrapping (modular) exponentiation. Computes `self.pow(exp)`, wrapping
  /// around at the boundary of the type.
  fn wrapping_pow(self, rhs: u32) -> Self;

  /// Calculates `self + rhs`
  ///
  /// Returns a tuple of the addition along with a boolean indicating whether
  /// an arithmetic overflow would occur. If an overflow would have occurred
  /// then the wrapped value is returned.
  fn overflowing_add(self, rhs: Self) -> (Self, bool);

  /// Calculates `self - rhs`
  ///
  /// Returns a tuple of the subtraction along with a boolean indicating
  /// whether an arithmetic overflow would occur. If an overflow would have
  /// occurred then the wrapped value is returned.
  fn overflowing_sub(self, rhs: Self) -> (Self, bool);

  /// Calculates the multiplication of `self` and `rhs`.
  ///
  /// Returns a tuple of the multiplication along with a boolean indicating
  /// whether an arithmetic overflow would occur. If an overflow would have
  /// occurred then the wrapped value is returned.
  fn overflowing_mul(self, rhs: Self) -> (Self, bool);

  /// Calculates the divisor when `self` is divided by `rhs`.
  ///
  /// Returns a tuple of the divisor along with a boolean indicating whether
  /// an arithmetic overflow would occur. If an overflow would occur then self
  /// is returned.
  ///
  /// # Panics
  ///
  /// This function will panic if `rhs` is 0.
  fn overflowing_div(self, rhs: Self) -> (Self, bool);

  /// Calculates the quotient of Euclidean division `self.div_euclid(rhs)`.
  ///
  /// Returns a tuple of the divisor along with a boolean indicating whether
  /// an arithmetic overflow would occur. If an overflow would occur then self
  /// is returned.
  ///
  /// # Panics
  ///
  /// This function will panic if `rhs` is 0.
  fn overflowing_div_euclid(self, rhs: Self) -> (Self, bool);

  /// Calculates the remainder when `self` is divided by `rhs`.
  ///
  /// Returns a tuple of the remainder after dividing along with a boolean
  /// indicating whether an arithmetic overflow would occur. If an overflow
  /// would occur then 0 is returned.
  ///
  /// # Panics
  ///
  /// This function will panic if `rhs` is 0.
  fn overflowing_rem(self, rhs: Self) -> (Self, bool);

  /// Overflowing Euclidean remainder. Calculates `self.rem_euclid(rhs)`.
  ///
  /// Returns a tuple of the remainder after dividing along with a boolean
  /// indicating whether an arithmetic overflow would occur. If an overflow
  /// would occur then 0 is returned.
  ///
  /// # Panics
  ///
  /// This function will panic if rhs is 0.
  fn overflowing_rem_euclid(self, rhs: Self) -> (Self, bool);

  /// Negates self, overflowing if this is equal to the minimum value.
  ///
  /// Returns a tuple of the negated version of self along with a boolean
  /// indicating whether an overflow happened. If `self` is the minimum value
  /// (e.g., `i32::MIN` for values of type `i32`), then the minimum value will
  /// be returned again and `true` will be returned for an overflow happening.
  fn overflowing_neg(self) -> (Self, bool);

  /// Shifts self left by `rhs` bits.
  ///
  /// Returns a tuple of the shifted version of self along with a boolean
  /// indicating whether the shift value was larger than or equal to the
  /// number of bits. If the shift value is too large, then value is masked
  /// (N-1) where N is the number of bits, and this value is then used to
  /// perform the shift.
  fn overflowing_shl(self, rhs: u32) -> (Self, bool);

  /// Shifts self right by `rhs` bits.
  ///
  /// Returns a tuple of the shifted version of self along with a boolean
  /// indicating whether the shift value was larger than or equal to the
  /// number of bits. If the shift value is too large, then value is masked
  /// (N-1) where N is the number of bits, and this value is then used to
  /// perform the shift.
  fn overflowing_shr(self, rhs: u32) -> (Self, bool);

  /// Raises self to the power of `exp`, using exponentiation by squaring.
  ///
  /// Returns a tuple of the exponentiation along with a bool indicating
  /// whether an overflow happened.
  fn overflowing_pow(self, rhs: u32) -> (Self, bool);

  /// Raises self to the power of `exp`, using exponentiation by squaring.
  fn pow(self, rhs: u32) -> Self;

  /// Calculates the quotient of Euclidean division of self by rhs.
  ///
  /// This computes the integer `n` such that
  /// `self = n * rhs + self.rem_euclid(rhs)`, with
  /// `0 <= self.rem_euclid(rhs) < rhs`.
  ///
  /// In other words, the result is `self / rhs` rounded to the integer `n`
  /// such that `self >= n * rhs`. If `self > 0`, this is equal to round
  /// towards zero (the default in Rust); if `self < 0`, this is equal to
  /// round towards +/- infinity.
  ///
  /// # Panics
  ///
  /// This function will panic if `rhs` is 0 or the division results in
  /// overflow.
  fn div_euclid(self, rhs: Self) -> Self;

  /// Calculates the least nonnegative remainder of `self (mod rhs)`.
  ///
  /// This is done as if by the Euclidean division algorithm -- given
  /// `r = self.rem_euclid(rhs)`, `self = rhs * self.div_euclid(rhs) + r`, and
  /// `0 <= r < abs(rhs)`.
  ///
  /// # Panics
  ///
  /// This function will panic if `rhs` is 0 or the division results in
  /// overflow.
  fn rem_euclid(self, rhs: Self) -> Self;
}

/// Declare that a type is a signed integer.
pub trait Signed: Integral + Neg {
  /// Checked absolute value. Computes `self.abs()`, returning `None` if
  /// `self == MIN`.
  fn checked_abs(self) -> Option<Self>;

  /// Wrapping (modular) absolute value. Computes `self.abs()`, wrapping
  /// around at the boundary of the type.
  ///
  /// The only case where such wrapping can occur is when one takes the
  /// absolute value of the negative minimal value for the type this is a
  /// positive value that is too large to represent in the type. In such a
  /// case, this function returns `MIN` itself.
  fn wrapping_abs(self) -> Self;

  /// Computes the absolute value of `self`.
  ///
  /// Returns a tuple of the absolute version of self along with a boolean
  /// indicating whether an overflow happened. If self is the minimum value
  /// (e.g., iN::MIN for values of type iN), then the minimum value will be
  /// returned again and true will be returned for an overflow happening.
  fn overflowing_abs(self) -> (Self, bool);

  //// Computes the absolute value of self.
  ///
  /// # Overflow behavior
  ///
  /// The absolute value of `iN::min_value()` cannot be represented as an
  /// `iN`, and attempting to calculate it will cause an overflow. This means
  /// that code in debug mode will trigger a panic on this case and optimized
  /// code will return `iN::min_value()` without a panic.
  fn abs(self) -> Self;

  /// Returns a number representing sign of `self`.
  ///
  /// - `0` if the number is zero
  /// - `1` if the number is positive
  /// - `-1` if the number is negative
  fn signum(self) -> Self;

  /// Returns `true` if `self` is positive and `false` if the number is zero
  /// or negative.
  fn is_positive(self) -> bool;

  /// Returns `true` if `self` is negative and `false` if the number is zero
  /// or positive.
  fn is_negative(self) -> bool;
}

/// Declare that a type is an unsigned integer.
pub trait Unsigned: Integral {
  /// Returns `true` if and only if `self == 2^k` for some `k`.
  fn is_power_of_two(self) -> bool;

  /// Returns the smallest power of two greater than or equal to `self`.
  ///
  /// When return value overflows (i.e., `self > (1 << (N-1))` for type `uN`),
  /// it panics in debug mode and return value is wrapped to 0 in release mode
  /// (the only situation in which method can return 0).
  fn next_power_of_two(self) -> Self;

  /// Returns the smallest power of two greater than or equal to `n`. If the
  /// next power of two is greater than the type’s maximum value, `None` is
  /// returned, otherwise the power of two is wrapped in `Some`.
  fn checked_next_power_of_two(self) -> Option<Self>;
}

/// Declare that a type is a floating-point number.
pub trait Floating:
  Numeric
  + LowerExp
  + UpperExp
  + Neg
  + From<f32>
  + From<i8>
  + From<i16>
  + From<u8>
  + From<u16>
{
  /// The unsigned integer type of the same width as `Self`.
  type Raw: Unsigned;

  /// The radix or base of the internal representation of `f32`.
  const RADIX: u32;

  /// Number of significant digits in base 2.
  const MANTISSA_DIGITS: u32;

  /// Approximate number of significant digits in base 10.
  const DIGITS: u32;

  /// [Machine epsilon] value for `f32`.
  ///
  /// This is the difference between `1.0` and the next larger representable
  /// number.
  ///
  /// [Machine epsilon]: https://en.wikipedia.org/wiki/Machine_epsilon
  const EPSILON: Self;

  /// Smallest finite `f32` value.
  const MIN: Self;

  /// Smallest positive normal `f32` value.
  const MIN_POSITIVE: Self;

  /// Largest finite `f32` value.
  const MAX: Self;

  /// One greater than the minimum possible normal power of 2 exponent.
  const MIN_EXP: i32;

  /// Maximum possible power of 2 exponent.
  const MAX_EXP: i32;

  /// Minimum possible normal power of 10 exponent.
  const MIN_10_EXP: i32;

  /// Maximum possible power of 10 exponent.
  const MAX_10_EXP: i32;

  /// Not a Number (NaN).
  const NAN: Self;

  /// Infinity (∞).
  const INFINITY: Self;

  /// Negative infinity (−∞).
  const NEG_INFINITY: Self;

  /// Archimedes' constant (π)
  const PI: Self;

  /// π/2
  const FRAC_PI_2: Self;

  /// π/3
  const FRAC_PI_3: Self;

  /// π/4
  const FRAC_PI_4: Self;

  /// π/6
  const FRAC_PI_6: Self;

  /// π/8
  const FRAC_PI_8: Self;

  /// 1/π
  const FRAC_1_PI: Self;

  /// 2/π
  const FRAC_2_PI: Self;

  /// 2/sqrt(π)
  const FRAC_2_SQRT_PI: Self;

  /// sqrt(2)
  const SQRT_2: Self;

  /// 1/sqrt(2)
  const FRAC_1_SQRT_2: Self;

  /// Euler’s number (e)
  const E: Self;

  /// log<sub>2</sub>(e)
  const LOG2_E: Self;

  /// log<sub>10</sub>(e)
  const LOG10_E: Self;

  /// ln(2)
  const LN_2: Self;

  /// ln(10)
  const LN_10: Self;

  //  These functions are only available in `std`, because they rely on the
  //  system math library `libm` which is not provided by `core`.

  /// Returns the largest integer less than or equal to a number.
  #[cfg(feature = "std")]
  fn floor(self) -> Self;

  /// Returns the smallest integer greater than or equal to a number.
  #[cfg(feature = "std")]
  fn ceil(self) -> Self;

  /// Returns the nearest integer to a number. Round half-way cases away from
  /// `0.0`.
  #[cfg(feature = "std")]
  fn round(self) -> Self;

  /// Returns the integer part of a number.
  #[cfg(feature = "std")]
  fn trunc(self) -> Self;

  /// Returns the fractional part of a number.
  #[cfg(feature = "std")]
  fn fract(self) -> Self;

  /// Computes the absolute value of `self`. Returns `NAN` if the
  /// number is `NAN`.
  #[cfg(feature = "std")]
  fn abs(self) -> Self;

  /// Returns a number that represents the sign of `self`.
  ///
  /// - `1.0` if the number is positive, `+0.0` or `INFINITY`
  /// - `-1.0` if the number is negative, `-0.0` or `NEG_INFINITY`
  /// - `NAN` if the number is `NAN`
  #[cfg(feature = "std")]
  fn signum(self) -> Self;

  /// Returns a number composed of the magnitude of `self` and the sign of
  /// `sign`.
  ///
  /// Equal to `self` if the sign of `self` and `sign` are the same, otherwise
  /// equal to `-self`. If `self` is a `NAN`, then a `NAN` with the sign of
  /// `sign` is returned.
  #[cfg(feature = "std")]
  fn copysign(self, sign: Self) -> Self;

  /// Fused multiply-add. Computes `(self * a) + b` with only one rounding
  /// error, yielding a more accurate result than an un-fused multiply-add.
  ///
  /// Using `mul_add` can be more performant than an un-fused multiply-add if
  /// the target architecture has a dedicated `fma` CPU instruction.
  #[cfg(feature = "std")]
  fn mul_add(self, a: Self, b: Self) -> Self;

  /// Calculates Euclidean division, the matching method for `rem_euclid`.
  ///
  /// This computes the integer `n` such that
  /// `self = n * rhs + self.rem_euclid(rhs)`.
  /// In other words, the result is `self / rhs` rounded to the integer `n`
  /// such that `self >= n * rhs`.
  #[cfg(feature = "std")]
  fn div_euclid(self, rhs: Self) -> Self;

  /// Calculates the least nonnegative remainder of `self (mod rhs)`.
  ///
  /// In particular, the return value `r` satisfies `0.0 <= r < rhs.abs()` in
  /// most cases. However, due to a floating point round-off error it can
  /// result in `r == rhs.abs()`, violating the mathematical definition, if
  /// `self` is much smaller than `rhs.abs()` in magnitude and `self < 0.0`.
  /// This result is not an element of the function's codomain, but it is the
  /// closest floating point number in the real numbers and thus fulfills the
  /// property `self == self.div_euclid(rhs) * rhs + self.rem_euclid(rhs)`
  /// approximatively.
  #[cfg(feature = "std")]
  fn rem_euclid(self, rhs: Self) -> Self;

  /// Raises a number to an integer power.
  ///
  /// Using this function is generally faster than using `powf`
  #[cfg(feature = "std")]
  fn powi(self, n: i32) -> Self;

  /// Raises a number to a floating point power.
  #[cfg(feature = "std")]
  fn powf(self, n: Self) -> Self;

  /// Returns the square root of a number.
  ///
  /// Returns NaN if `self` is a negative number.
  #[cfg(feature = "std")]
  fn sqrt(self) -> Self;

  /// Returns `e^(self)`, (the exponential function).
  #[cfg(feature = "std")]
  fn exp(self) -> Self;

  /// Returns `2^(self)`.
  #[cfg(feature = "std")]
  fn exp2(self) -> Self;

  /// Returns the natural logarithm of the number.
  #[cfg(feature = "std")]
  fn ln(self) -> Self;

  /// Returns the logarithm of the number with respect to an arbitrary base.
  ///
  /// The result may not be correctly rounded owing to implementation details;
  /// `self.log2()` can produce more accurate results for base 2, and
  /// `self.log10()` can produce more accurate results for base 10.
  #[cfg(feature = "std")]
  fn log(self, base: Self) -> Self;

  /// Returns the base 2 logarithm of the number.
  #[cfg(feature = "std")]
  fn log2(self) -> Self;

  /// Returns the base 10 logarithm of the number.
  #[cfg(feature = "std")]
  fn log10(self) -> Self;

  /// Returns the cubic root of a number.
  #[cfg(feature = "std")]
  fn cbrt(self) -> Self;

  /// Computes the sine of a number (in radians).
  #[cfg(feature = "std")]
  fn hypot(self, other: Self) -> Self;

  /// Computes the sine of a number (in radians).
  #[cfg(feature = "std")]
  fn sin(self) -> Self;

  /// Computes the cosine of a number (in radians).
  #[cfg(feature = "std")]
  fn cos(self) -> Self;

  /// Computes the tangent of a number (in radians).
  #[cfg(feature = "std")]
  fn tan(self) -> Self;

  /// Computes the arcsine of a number. Return value is in radians in the
  /// range [-pi/2, pi/2] or NaN if the number is outside the range [-1, 1].
  #[cfg(feature = "std")]
  fn asin(self) -> Self;

  /// Computes the arccosine of a number. Return value is in radians in the
  /// range [0, pi] or NaN if the number is outside the range [-1, 1].
  #[cfg(feature = "std")]
  fn acos(self) -> Self;

  /// Computes the arctangent of a number. Return value is in radians in the
  /// range [-pi/2, pi/2];
  #[cfg(feature = "std")]
  fn atan(self) -> Self;

  /// Computes the four quadrant arctangent of `self` (`y`) and `other` (`x`)
  /// in radians.
  ///
  /// - `x = 0`, `y = 0`: `0`
  /// - `x >= 0`: `arctan(y/x)` -> `[-pi/2, pi/2]`
  /// - `y >= 0`: `arctan(y/x) + pi` -> `(pi/2, pi]`
  /// - `y < 0`: `arctan(y/x) - pi` -> `(-pi, -pi/2)`
  #[cfg(feature = "std")]
  fn atan2(self, other: Self) -> Self;

  /// Simultaneously computes the sine and cosine of the number, `x`. Returns
  /// `(sin(x), cos(x))`.
  #[cfg(feature = "std")]
  fn sin_cos(self) -> (Self, Self);

  /// Returns `e^(self) - 1` in a way that is accurate even if the number is
  /// close to zero.
  #[cfg(feature = "std")]
  fn exp_m1(self) -> Self;

  /// Returns `ln(1+n)` (natural logarithm) more accurately than if the
  /// operations were performed separately.
  #[cfg(feature = "std")]
  fn ln_1p(self) -> Self;

  /// Hyperbolic sine function.
  #[cfg(feature = "std")]
  fn sinh(self) -> Self;

  /// Hyperbolic cosine function.
  #[cfg(feature = "std")]
  fn cosh(self) -> Self;

  /// Hyperbolic tangent function.
  #[cfg(feature = "std")]
  fn tanh(self) -> Self;

  /// Inverse hyperbolic sine function.
  #[cfg(feature = "std")]
  fn asinh(self) -> Self;

  /// Inverse hyperbolic cosine function.
  #[cfg(feature = "std")]
  fn acosh(self) -> Self;

  /// Inverse hyperbolic tangent function.
  #[cfg(feature = "std")]
  fn atanh(self) -> Self;

  /// Returns `true` if this value is `NaN`.
  fn is_nan(self) -> bool;

  /// Returns `true` if this value is positive infinity or negative infinity,
  /// and `false` otherwise.
  fn is_infinite(self) -> bool;

  /// Returns `true` if this number is neither infinite nor `NaN`.
  fn is_finite(self) -> bool;

  /// Returns `true` if the number is neither zero, infinite, [subnormal], or
  /// `NaN`.
  ///
  /// [subnormal]: https://en.wixipedia.org/wiki/Denormal_number
  fn is_normal(self) -> bool;

  /// Returns the floating point category of the number. If only one property
  /// is going to be tested, it is generally faster to use the specific
  /// predicate instead.
  fn classify(self) -> FpCategory;

  /// Returns `true` if `self` has a positive sign, including `+0.0`, `NaN`s
  /// with positive sign bit and positive infinity.
  fn is_sign_positive(self) -> bool;

  /// Returns `true` if `self` has a negative sign, including `-0.0`, `NaN`s
  /// with negative sign bit and negative infinity.
  fn is_sign_negative(self) -> bool;

  /// Takes the reciprocal (inverse) of a number, `1/x`.
  fn recip(self) -> Self;

  /// Converts radians to degrees.
  fn to_degrees(self) -> Self;

  /// Converts degrees to radians.
  fn to_radians(self) -> Self;

  /// Returns the maximum of the two numbers.
  fn max(self, other: Self) -> Self;

  /// Returns the minimum of the two numbers.
  fn min(self, other: Self) -> Self;

  /// Raw transmutation to `u32`.
  ///
  /// This is currently identical to `transmute::<f32, u32>(self)` on all
  /// platforms.
  ///
  /// See `from_bits` for some discussion of the portability of this operation
  /// (there are almost no issues).
  ///
  /// Note that this function is distinct from `as` casting, which attempts to
  /// preserve the *numeric* value, and not the bitwise value.
  fn to_bits(self) -> Self::Raw;

  /// Raw transmutation from `u32`.
  ///
  /// This is currently identical to `transmute::<u32, f32>(v)` on all
  /// platforms. It turns out this is incredibly portable, for two reasons:
  ///
  /// - Floats and Ints have the same endianness on all supported platforms.
  /// - IEEE-754 very precisely specifies the bit layout of floats.
  ///
  /// However there is one caveat: prior to the 2008 version of IEEE-754, how
  /// to interpret the NaN signaling bit wasn't actually specified. Most
  /// platforms (notably x86 and ARM) picked the interpretation that was
  /// ultimately standardized in 2008, but some didn't (notably MIPS). As a
  /// result, all signaling NaNs on MIPS are quiet NaNs on x86, and
  /// vice-versa.
  ///
  /// Rather than trying to preserve signaling-ness cross-platform, this
  /// implementation favors preserving the exact bits. This means that
  /// any payloads encoded in NaNs will be preserved even if the result of
  /// this method is sent over the network from an x86 machine to a MIPS one.
  ///
  /// If the results of this method are only manipulated by the same
  /// architecture that produced them, then there is no portability concern.
  ///
  /// If the input isn't NaN, then there is no portability concern.
  ///
  /// If you don't care about signalingness (very likely), then there is no
  /// portability concern.
  ///
  /// Note that this function is distinct from `as` casting, which attempts to
  /// preserve the *numeric* value, and not the bitwise value.
  fn from_bits(bits: Self::Raw) -> Self;
}

/// Declare that a type is exactly eight bits wide.
pub trait Is8: Numeric {}

/// Declare that a type is exactly sixteen bits wide.
pub trait Is16: Numeric {}

/// Declare that a type is exactly thirty-two bits wide.
pub trait Is32: Numeric {}

/// Declare that a type is exactly sixty-four bits wide.
pub trait Is64: Numeric {}

/// Declare that a type is exactly one hundred twenty-eight bits wide.
pub trait Is128: Numeric {}

/// Declare that a type is eight or more bits wide.
pub trait AtLeast8: Numeric {}

/// Declare that a type is sixteen or more bits wide.
pub trait AtLeast16: Numeric {}

/// Declare that a type is thirty-two or more bits wide.
pub trait AtLeast32: Numeric {}

/// Declare that a type is sixty-four or more bits wide.
pub trait AtLeast64: Numeric {}

/// Declare that a type is one hundred twenty-eight or more bits wide.
pub trait AtLeast128: Numeric {}

/// Declare that a type is eight or fewer bits wide.
pub trait AtMost8: Numeric {}

/// Declare that a type is sixteen or fewer bits wide.
pub trait AtMost16: Numeric {}

/// Declare that a type is thirty-two or fewer bits wide.
pub trait AtMost32: Numeric {}

/// Declare that a type is sixty-four or fewer bits wide.
pub trait AtMost64: Numeric {}

/// Declare that a type is one hundred twenty-eight or fewer bits wide.
pub trait AtMost128: Numeric {}

/// Creates new wrapper functions that forward to inherent items of the same
/// name and signature.
macro_rules! func {
  (
    $(@$std:literal)?
    $name:ident (self$(, $arg:ident: $t:ty)*) $(-> $ret:ty)?;
    $($tt:tt)*
  ) => {
    $(#[cfg(feature = $std)])?
    fn $name(self$(, $arg: $t)*) $(-> $ret)?
    {
      <Self>::$name(self$(, $arg)*)
    }

    func!($($tt)*);
  };
  (
    $(@$std:literal)?
    $name:ident(&self$(, $arg:ident: $t:ty)*) $(-> $ret:ty)?;
    $($tt:tt)*
  ) => {
    $(#[cfg(feature = $std)])?
    fn $name(&self$(, $arg: $t)*) $(-> $ret)?
    {
      <Self>::$name(&self$(, $arg )*)
    }

    func!($($tt)*);
  };
  (
    $(@$std:literal)?
    $name:ident(&mut self$(, $arg:ident: $t:ty)*) $(-> $ret:ty)?;
    $($tt:tt)*
  ) => {
    $(#[cfg(feature = $std)])?
    fn $name(&mut self$(, $arg: $t)*) $(-> $ret)?
    {
      <Self>::$name(&mut self$(, $arg)*)
    }

    func!($($tt)*);
  };
  (
    $(@$std:literal)?
    $name:ident($($arg:ident: $t:ty),* $(,)?) $(-> $ret:ty)?;
    $($tt:tt)*
  ) => {
    $(#[cfg(feature = $std)])?
    fn $name($($arg: $t),*) $(-> $ret)?
    {
      <Self>::$name($($arg),*)
    }

    func!($($tt)*);
  };
  () => {};
}

macro_rules! impl_for {
  ( Fundamental => $($t:ty => $is_zero:expr),+ $(,)? ) => { $(
    impl Fundamental for $t {
      #[inline(always)]
      #[allow(clippy::redundant_closure_call)]
      fn as_bool(self) -> bool { ($is_zero)(self) }

      #[inline(always)]
      fn as_char(self) -> Option<char> {
        core::char::from_u32(self as u32)
      }

      #[inline(always)]
      fn as_i8(self) -> i8 { self as i8 }

      #[inline(always)]
      fn as_i16(self) -> i16 { self as i16 }

      #[inline(always)]
      fn as_i32(self) -> i32 { self as i32 }

      #[inline(always)]
      fn as_i64(self) -> i64 { self as i64 }

      #[inline(always)]
      fn as_i128(self) -> i128 { self as i128 }

      #[inline(always)]
      fn as_isize(self) -> isize { self as isize }

      #[inline(always)]
      fn as_u8(self) -> u8 { self as u8 }

      #[inline(always)]
      fn as_u16(self) -> u16 { self as u16 }

      #[inline(always)]
      fn as_u32(self) -> u32 { self as u32 }

      #[inline(always)]
      fn as_u64(self) -> u64 { self as u64 }

      #[inline(always)]
      fn as_u128(self) ->u128 { self as u128 }

      #[inline(always)]
      fn as_usize(self) -> usize { self as usize }

      #[inline(always)]
      fn as_f32(self) -> f32 { self as u32 as f32 }

      #[inline(always)]
      fn as_f64(self) -> f64 { self as u64 as f64 }
    }
  )+ };
  ( Numeric => $($t:ty),+ $(,)? ) => { $(
    impl Numeric for $t {
      type Bytes = [u8; core::mem::size_of::<Self>()];

      func! {
        to_be_bytes(self) -> Self::Bytes;
        to_le_bytes(self) -> Self::Bytes;
        to_ne_bytes(self) -> Self::Bytes;
        from_be_bytes(bytes: Self::Bytes) -> Self;
        from_le_bytes(bytes: Self::Bytes) -> Self;
        from_ne_bytes(bytes: Self::Bytes) -> Self;
      }
    }
  )+ };
  ( Integral => $($t:ty),+ $(,)? ) => { $(
    impl Integral for $t {
      const ZERO: Self = 0;
      const ONE: Self = 1;
      const MIN: Self = <Self>::min_value();
      const MAX: Self = <Self>::max_value();

      const BITS: u32 = <Self>::BITS;

      func! {
        min_value() -> Self;
        max_value() -> Self;
        from_str_radix(src: &str, radix: u32) -> Result<Self, ParseIntError>;
        count_ones(self) -> u32;
        count_zeros(self) -> u32;
        leading_zeros(self) -> u32;
        trailing_zeros(self) -> u32;
        leading_ones(self) -> u32;
        trailing_ones(self) -> u32;
        rotate_left(self, n: u32) -> Self;
        rotate_right(self, n: u32) -> Self;
        swap_bytes(self) -> Self;
        reverse_bits(self) -> Self;
        from_be(self) -> Self;
        from_le(self) -> Self;
        to_be(self) -> Self;
        to_le(self) -> Self;
        checked_add(self, rhs: Self) -> Option<Self>;
        checked_sub(self, rhs: Self) -> Option<Self>;
        checked_mul(self, rhs: Self) -> Option<Self>;
        checked_div(self, rhs: Self) -> Option<Self>;
        checked_div_euclid(self, rhs: Self) -> Option<Self>;
        checked_rem(self, rhs: Self) -> Option<Self>;
        checked_rem_euclid(self, rhs: Self) -> Option<Self>;
        checked_neg(self) -> Option<Self>;
        checked_shl(self, rhs: u32) -> Option<Self>;
        checked_shr(self, rhs: u32) -> Option<Self>;
        checked_pow(self, rhs: u32) -> Option<Self>;
        saturating_add(self, rhs: Self) -> Self;
        saturating_sub(self, rhs: Self) -> Self;
        saturating_mul(self, rhs: Self) -> Self;
        saturating_pow(self, rhs: u32) -> Self;
        wrapping_add(self, rhs: Self) -> Self;
        wrapping_sub(self, rhs: Self) -> Self;
        wrapping_mul(self, rhs: Self) -> Self;
        wrapping_div(self, rhs: Self) -> Self;
        wrapping_div_euclid(self, rhs: Self) -> Self;
        wrapping_rem(self, rhs: Self) -> Self;
        wrapping_rem_euclid(self, rhs: Self) -> Self;
        wrapping_neg(self) -> Self;
        wrapping_shl(self, rhs: u32) -> Self;
        wrapping_shr(self, rhs: u32) -> Self;
        wrapping_pow(self, rhs: u32) -> Self;
        overflowing_add(self, rhs: Self) -> (Self, bool);
        overflowing_sub(self, rhs: Self) -> (Self, bool);
        overflowing_mul(self, rhs: Self) -> (Self, bool);
        overflowing_div(self, rhs: Self) -> (Self, bool);
        overflowing_div_euclid(self, rhs: Self) -> (Self, bool);
        overflowing_rem(self, rhs: Self) -> (Self, bool);
        overflowing_rem_euclid(self, rhs: Self) -> (Self, bool);
        overflowing_neg(self) -> (Self, bool);
        overflowing_shl(self, rhs: u32) -> (Self, bool);
        overflowing_shr(self, rhs: u32) -> (Self, bool);
        overflowing_pow(self, rhs: u32) -> (Self, bool);
        pow(self, rhs: u32) -> Self;
        div_euclid(self, rhs: Self) -> Self;
        rem_euclid(self, rhs: Self) -> Self;
      }
    }
  )+ };
  ( Signed => $($t:ty),+ $(,)? ) => { $(
    impl Signed for $t {
      func! {
        checked_abs(self) -> Option<Self>;
        wrapping_abs(self) -> Self;
        overflowing_abs(self) -> (Self, bool);
        abs(self) -> Self;
        signum(self) -> Self;
        is_positive(self) -> bool;
        is_negative(self) -> bool;
      }
    }
  )+ };
  ( Unsigned => $($t:ty),+ $(,)? ) => { $(
    impl Unsigned for $t {
      func! {
        is_power_of_two(self) -> bool;
        next_power_of_two(self) -> Self;
        checked_next_power_of_two(self) -> Option<Self>;
      }
    }
  )+ };
  ( Floating => $($t:ident | $u:ty),+ $(,)? ) => { $(
    impl Floating for $t {
      type Raw = $u;

      const RADIX: u32 = core::$t::RADIX;
      const MANTISSA_DIGITS: u32 = core::$t::MANTISSA_DIGITS;
      const DIGITS: u32 = core::$t::DIGITS;
      const EPSILON: Self = core::$t::EPSILON;
      const MIN: Self = core::$t::MIN;
      const MIN_POSITIVE: Self = core::$t::MIN_POSITIVE;
      const MAX: Self = core::$t::MAX;
      const MIN_EXP: i32 = core::$t::MIN_EXP;
      const MAX_EXP: i32 = core::$t::MAX_EXP;
      const MIN_10_EXP: i32 = core::$t::MIN_10_EXP;
      const MAX_10_EXP: i32 = core::$t::MAX_10_EXP;
      const NAN: Self = core::$t::NAN;
      const INFINITY: Self = core::$t::INFINITY;
      const NEG_INFINITY: Self = core::$t::NEG_INFINITY;

      const PI: Self = core::$t::consts::PI;
      const FRAC_PI_2: Self = core::$t::consts::FRAC_PI_2;
      const FRAC_PI_3: Self = core::$t::consts::FRAC_PI_3;
      const FRAC_PI_4: Self = core::$t::consts::FRAC_PI_4;
      const FRAC_PI_6: Self = core::$t::consts::FRAC_PI_6;
      const FRAC_PI_8: Self = core::$t::consts::FRAC_PI_8;
      const FRAC_1_PI: Self = core::$t::consts::FRAC_1_PI;
      const FRAC_2_PI: Self = core::$t::consts::FRAC_2_PI;
      const FRAC_2_SQRT_PI: Self = core::$t::consts::FRAC_2_SQRT_PI;
      const SQRT_2: Self = core::$t::consts::SQRT_2;
      const FRAC_1_SQRT_2: Self = core::$t::consts::FRAC_1_SQRT_2;
      const E: Self = core::$t::consts::E;
      const LOG2_E: Self = core::$t::consts::LOG2_E;
      const LOG10_E: Self = core::$t::consts::LOG10_E;
      const LN_2: Self = core::$t::consts::LN_2;
      const LN_10: Self = core::$t::consts::LN_10;

      func! {
        @"std" floor(self) -> Self;
        @"std" ceil(self) -> Self;
        @"std" round(self) -> Self;
        @"std" trunc(self) -> Self;
        @"std" fract(self) -> Self;
        @"std" abs(self) -> Self;
        @"std" signum(self) -> Self;
        @"std" copysign(self, sign: Self) -> Self;
        @"std" mul_add(self, a: Self, b: Self) -> Self;
        @"std" div_euclid(self, rhs: Self) -> Self;
        @"std" rem_euclid(self, rhs: Self) -> Self;
        @"std" powi(self, n: i32) -> Self;
        @"std" powf(self, n: Self) -> Self;
        @"std" sqrt(self) -> Self;
        @"std" exp(self) -> Self;
        @"std" exp2(self) -> Self;
        @"std" ln(self) -> Self;
        @"std" log(self, base: Self) -> Self;
        @"std" log2(self) -> Self;
        @"std" log10(self) -> Self;
        @"std" cbrt(self) -> Self;
        @"std" hypot(self, other: Self) -> Self;
        @"std" sin(self) -> Self;
        @"std" cos(self) -> Self;
        @"std" tan(self) -> Self;
        @"std" asin(self) -> Self;
        @"std" acos(self) -> Self;
        @"std" atan(self) -> Self;
        @"std" atan2(self, other: Self) -> Self;
        @"std" sin_cos(self) -> (Self, Self);
        @"std" exp_m1(self) -> Self;
        @"std" ln_1p(self) -> Self;
        @"std" sinh(self) -> Self;
        @"std" cosh(self) -> Self;
        @"std" tanh(self) -> Self;
        @"std" asinh(self) -> Self;
        @"std" acosh(self) -> Self;
        @"std" atanh(self) -> Self;
        is_nan(self) -> bool;
        is_infinite(self) -> bool;
        is_finite(self) -> bool;
        is_normal(self) -> bool;
        classify(self) -> FpCategory;
        is_sign_positive(self) -> bool;
        is_sign_negative(self) -> bool;
        recip(self) -> Self;
        to_degrees(self) -> Self;
        to_radians(self) -> Self;
        max(self, other: Self) -> Self;
        min(self, other: Self) -> Self;
        to_bits(self) -> Self::Raw;
        from_bits(bits: Self::Raw) -> Self;
      }
    }
  )+ };
  ( $which:ty => $($t:ty),+ $(,)? ) => { $(
    impl $which for $t {}
  )+ };
}

impl_for!(Fundamental =>
  bool => |this: bool| !this,
  char => |this| this != '\0',
  i8 => |this| this != 0,
  i16 => |this| this != 0,
  i32 => |this| this != 0,
  i64 => |this| this != 0,
  i128 => |this| this != 0,
  isize => |this| this != 0,
  u8 => |this| this != 0,
  u16 => |this| this != 0,
  u32 => |this| this != 0,
  u64 => |this| this != 0,
  u128 => |this| this != 0,
  usize => |this| this != 0,
  f32 => |this: f32| (-Self::EPSILON ..= Self::EPSILON).contains(&this),
  f64 => |this: f64| (-Self::EPSILON ..= Self::EPSILON).contains(&this),
);
impl_for!(Numeric => i8, i16, i32, i64, i128, isize, u8, u16, u32, u64, u128, usize, f32, f64);
impl_for!(Integral => i8, i16, i32, i64, i128, isize, u8, u16, u32, u64, u128, usize);
impl_for!(Signed => i8, i16, i32, i64, i128, isize);
impl_for!(Unsigned => u8, u16, u32, u64, u128, usize);
impl_for!(Floating => f32 | u32, f64 | u64);

impl_for!(Is8 => i8, u8);
impl_for!(Is16 => i16, u16);
impl_for!(Is32 => i32, u32, f32);
impl_for!(Is64 => i64, u64, f64);
impl_for!(Is128 => i128, u128);

#[cfg(target_pointer_width = "16")]
impl_for!(Is16 => isize, usize);

#[cfg(target_pointer_width = "32")]
impl_for!(Is32 => isize, usize);

#[cfg(target_pointer_width = "64")]
impl_for!(Is64 => isize, usize);

impl_for!(AtLeast8 => i8, i16, i32, i64, i128, isize, u8, u16, u32, u64, u128, usize, f32, f64);
impl_for!(AtLeast16 => i16, i32, i64, i128, u16, u32, u64, u128, f32, f64);
impl_for!(AtLeast32 => i32, i64, i128, u32, u64, u128, f32, f64);
impl_for!(AtLeast64 => i64, i128, u64, u128, f64);
impl_for!(AtLeast128 => i128, u128);

#[cfg(any(
  target_pointer_width = "16",
  target_pointer_width = "32",
  target_pointer_width = "64"
))]
impl_for!(AtLeast16 => isize, usize);

#[cfg(any(target_pointer_width = "32", target_pointer_width = "64"))]
impl_for!(AtLeast32 => isize, usize);

#[cfg(target_pointer_width = "64")]
impl_for!(AtLeast64 => isize, usize);

impl_for!(AtMost8 => i8, u8);
impl_for!(AtMost16 => i8, i16, u8, u16);
impl_for!(AtMost32 => i8, i16, i32, u8, u16, u32, f32);
impl_for!(AtMost64 => i8, i16, i32, i64, isize, u8, u16, u32, u64, usize, f32, f64);
impl_for!(AtMost128 => i8, i16, i32, i64, i128, isize, u8, u16, u32, u64, u128, usize, f32, f64);

#[cfg(target_pointer_width = "16")]
impl_for!(AtMost16 => isize, usize);

#[cfg(any(target_pointer_width = "16", target_pointer_width = "32"))]
impl_for!(AtMost32 => isize, usize);

#[cfg(test)]
mod tests {
  use super::*;
  use static_assertions::*;

  assert_impl_all!(bool: Fundamental);
  assert_impl_all!(char: Fundamental);

  assert_impl_all!(i8: Integral, Signed, Is8);
  assert_impl_all!(i16: Integral, Signed, Is16);
  assert_impl_all!(i32: Integral, Signed, Is32);
  assert_impl_all!(i64: Integral, Signed, Is64);
  assert_impl_all!(i128: Integral, Signed, Is128);
  assert_impl_all!(isize: Integral, Signed);

  assert_impl_all!(u8: Integral, Unsigned, Is8);
  assert_impl_all!(u16: Integral, Unsigned, Is16);
  assert_impl_all!(u32: Integral, Unsigned, Is32);
  assert_impl_all!(u64: Integral, Unsigned, Is64);
  assert_impl_all!(u128: Integral, Unsigned, Is128);
  assert_impl_all!(usize: Integral, Unsigned);

  assert_impl_all!(f32: Floating, Is32);
  assert_impl_all!(f64: Floating, Is64);
}

Coverage Report

Created: 2025-07-11 06:43