Enum Number

#[non_exhaustive]
pub enum Number {
    I8(i8),
    I16(i16),
    I32(i32),
    I64(i64),
    U8(u8),
    U16(u16),
    U32(u32),
    U64(u64),
    F32(F32),
    F64(F64),
}

A wrapper for any numeric primitive type in Rust.

Some varints of the Number enum are enabled by features:

• Number::I128 and Number::U128 by the integer128 feature

To ensure that feature unification does not break matching over Number, the Number enum is non-exhaustive.

Exhaustively matching on Number in tests

If you want to ensure that you exhaustively handle every variant, you can match on the hidden Number::__NonExhaustive(x) variant by using the x.never() -> ! method.

Matching on this variant means that your code may break when RON is upgraded or when feature unification enables further variants in the Number enum than your code expects.

It is your responsibility to only ever match on Number::__NonExhaustive inside tests, e.g. by using #[cfg(test)] on the particular match arm, to ensure that only your tests break (e.g. in CI) when your code is not exhaustively matching on every variant, e.g. after a version upgrade or feature unification.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

I8(i8)

I16(i16)

I32(i32)

I64(i64)

U8(u8)

U16(u16)

U32(u32)

U64(u64)

F32(F32)

F64(F64)

Implementations

impl Number

pub fn visit<'de, V: Visitor<'de>, E: Error>( &self, visitor: V, ) -> Result<V::Value, E>

impl Number

pub fn new(v: impl Into<Number>) -> Self

Construct a new number.

pub fn into_f64(self) -> f64

Returns the f64 representation of the Number regardless of whether the number is stored as a float or integer.

Example

let i = Number::new(5);
let f = Number::new(2.0);
assert_eq!(i.into_f64(), 5.0);
assert_eq!(f.into_f64(), 2.0);

Trait Implementations

impl Clone for Number

fn clone(&self) -> Number

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Number

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

Formats the value using the given formatter.

impl From<f32> for Number

fn from(v: f32) -> Number

Converts to this type from the input type.

impl From<f64> for Number

fn from(v: f64) -> Number

Converts to this type from the input type.

impl From<i16> for Number

fn from(v: i16) -> Number

Converts to this type from the input type.

impl From<i32> for Number

fn from(v: i32) -> Number

Converts to this type from the input type.

impl From<i64> for Number

fn from(v: i64) -> Number

Converts to this type from the input type.

impl From<i8> for Number

fn from(v: i8) -> Number

Converts to this type from the input type.

impl From<u16> for Number

fn from(v: u16) -> Number

Converts to this type from the input type.

impl From<u32> for Number

fn from(v: u32) -> Number

Converts to this type from the input type.

impl From<u64> for Number

fn from(v: u64) -> Number

Converts to this type from the input type.

impl From<u8> for Number

fn from(v: u8) -> Number

Converts to this type from the input type.

impl Hash for Number

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 Ord for Number

fn cmp(&self, other: &Number) -> 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 PartialEq for Number

fn eq(&self, other: &Number) -> 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 PartialOrd for Number

fn partial_cmp(&self, other: &Number) -> 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 Serialize for Number

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

Serialize this value into the given Serde serializer.

impl Copy for Number

impl Eq for Number

impl StructuralPartialEq for Number