Enum Number 

#[non_exhaustive]
pub enum Number {
    Integer(i64),
    Unsigned(u64),
    Float(f64),
}

Represents a YAML number.

Marked #[non_exhaustive] so future numeric variants can be added without breaking downstream match arms. Callers must include a _ => { … } wildcard when pattern-matching. Adding Unsigned(u64) behind feature = "lossless-u64" is the first use of this contract; see ADR-0004.

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.

Integer(i64)

A signed integer.

Unsigned(u64)

An unsigned integer that cannot be represented by i64.

Float(f64)

A floating-point number.

Implementations

impl Number

pub fn as_i64(&self) -> Option<i64>

Returns the number as an i64 if it is an integer.

Floats return None even when their value happens to be a whole number; the type tag is part of the test.

Examples

use noyalib::Number;
assert_eq!(Number::Integer(42).as_i64(), Some(42));
assert_eq!(Number::Float(1.0).as_i64(), None);

pub fn as_u64(&self) -> Option<u64>

Returns the number as a u64 if it is a non-negative integer.

Negative integers and floats return None.

Examples

use noyalib::Number;
assert_eq!(Number::Integer(42).as_u64(), Some(42));
assert_eq!(Number::Integer(-1).as_u64(), None);
assert_eq!(Number::Float(1.0).as_u64(), None);

pub fn as_f64(&self) -> f64

Returns the number as an f64.

Always succeeds — integers are widened to f64 (with the usual i64 → f64 precision loss for magnitudes above 2^53), floats pass through unchanged.

Examples

use noyalib::Number;
assert_eq!(Number::Integer(42).as_f64(), 42.0);
assert_eq!(Number::Float(0.5).as_f64(), 0.5);

pub fn is_integer(&self) -> bool

Returns true if the number is an integer.

Examples

use noyalib::Number;
assert!(Number::Integer(42).is_integer());
assert!(!Number::Float(1.0).is_integer());

pub fn is_float(&self) -> bool

Returns true if the number is a float.

Examples

use noyalib::Number;
assert!(Number::Float(1.0).is_float());
assert!(!Number::Integer(42).is_float());

pub fn is_i64(&self) -> bool

Returns true if the number can be represented as an i64.

True for all integer values, false for floats.

Examples

use noyalib::Number;
assert!(Number::Integer(42).is_i64());
assert!(!Number::Float(42.0).is_i64());

pub fn is_u64(&self) -> bool

Returns true if the number can be represented as a u64.

True for non-negative integers, false otherwise.

Examples

use noyalib::Number;
assert!(Number::Integer(42).is_u64());
assert!(!Number::Integer(-1).is_u64());
assert!(!Number::Float(1.0).is_u64());

pub fn is_f64(&self) -> bool

Returns true if the number can be represented as an f64.

Always true — both integers and floats convert to f64 (with the usual precision caveats for very large integers).

Examples

use noyalib::Number;
assert!(Number::Integer(42).is_f64());
assert!(Number::Float(1.0).is_f64());

pub fn is_nan(&self) -> bool

Returns true if the number is NaN (Not a Number).

Integers are never NaN — only floats with the IEEE 754 NaN bit pattern.

Examples

use noyalib::Number;
assert!(Number::Float(f64::NAN).is_nan());
assert!(!Number::Float(0.0).is_nan());
assert!(!Number::Integer(0).is_nan());

pub fn is_infinite(&self) -> bool

Returns true if the number is positive or negative infinity.

Integers are always finite — only Number::Float(±inf) returns true.

Examples

use noyalib::Number;
assert!(Number::Float(f64::INFINITY).is_infinite());
assert!(Number::Float(f64::NEG_INFINITY).is_infinite());
assert!(!Number::Integer(i64::MAX).is_infinite());

pub fn is_finite(&self) -> bool

Returns true if the number is neither infinite nor NaN.

Integers are always finite; floats are finite when neither ±∞ nor NaN.

Examples

use noyalib::Number;
assert!(Number::Integer(0).is_finite());
assert!(Number::Float(0.5).is_finite());
assert!(!Number::Float(f64::NAN).is_finite());
assert!(!Number::Float(f64::INFINITY).is_finite());

Trait Implementations

impl<'a> Arbitrary<'a> for Number

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

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

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

impl Debug for Number

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

Formats the value using the given formatter.

impl Display for Number

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

Formats the value using the given formatter.

impl Eq for Number

impl From<Number> for Value

fn from(v: Number) -> Self

Converts to this type from the input type.

impl From<f32> for Number

fn from(v: f32) -> Self

Converts to this type from the input type.

impl From<f64> for Number

fn from(v: f64) -> Self

Converts to this type from the input type.

impl From<i8> for Number

fn from(v: i8) -> Self

Converts to this type from the input type.

impl From<i16> for Number

fn from(v: i16) -> Self

Converts to this type from the input type.

impl From<i32> for Number

fn from(v: i32) -> Self

Converts to this type from the input type.

impl From<i64> for Number

fn from(v: i64) -> Self

Converts to this type from the input type.

impl From<isize> for Number

fn from(v: isize) -> Self

Converts to this type from the input type.

impl From<u8> for Number

fn from(v: u8) -> Self

Converts to this type from the input type.

impl From<u16> for Number

fn from(v: u16) -> Self

Converts to this type from the input type.

impl From<u32> for Number

fn from(v: u32) -> Self

Converts to this type from the input type.

impl From<u64> for Number

fn from(v: u64) -> Self

Converts to this type from the input type.

impl From<usize> for Number

fn from(v: usize) -> Self

Converts to this type from the input type.

impl FromStr for Number

type Err = ParseNumberError

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 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

Total ordering for Number.

Same-kind comparisons (Integer vs Integer, Unsigned vs Unsigned, Float vs Float) use exact arithmetic. Cross-kind comparisons between integers and floats widen the integer side to f64, matching the existing Integer ↔ Float arms. Values with magnitude above 2^53 may compare Ordering::Equal to nearby floats because of IEEE rounding; for exact ordering, compare within the same kind.

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

This method returns an Ordering between self and other.

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

where Self: Sized,

Compares and returns the maximum of two values.

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

where Self: Sized,

Compares and returns the minimum of two values.

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

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for Number

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

Equality operator ==.

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

Inequality operator !=.

impl PartialOrd for Number

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

fn stream<'sval, S: Stream<'sval> + ?Sized>( &'sval self, stream: &mut S, ) -> Result

Stream this value through a [Stream].

fn tag(&self) -> Option<Tag>

Get the tag of this value, if there is one.

fn to_bool(&self) -> Option<bool>

Try convert this value into a boolean.

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

Try convert this value into a 32bit binary floating point number.

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

Try convert this value into a 64bit binary floating point number.

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

Try convert this value into a signed 8bit integer.

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

Try convert this value into a signed 16bit integer.

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

Try convert this value into a signed 32bit integer.

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

Try convert this value into a signed 64bit integer.

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

Try convert this value into a signed 128bit integer.

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

Try convert this value into an unsigned 8bit integer.

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

Try convert this value into an unsigned 16bit integer.

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

Try convert this value into an unsigned 32bit integer.

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

Try convert this value into an unsigned 64bit integer.

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

Try convert this value into an unsigned 128bit integer.

fn to_text(&self) -> Option<&str>

Try convert this value into a text string.

fn to_binary(&self) -> Option<&[u8]>

Try convert this value into a bitstring.