Struct lexpr::number::Number

pub struct Number { /* fields omitted */ }

Represents an S-expression number, whether integer or floating point.

Methods

impl Number

pub fn is_i64(&self) -> bool

Returns true if the Number is an integer between i64::MIN and i64::MAX.

For any Number on which is_i64 returns true, as_i64 is guaranteed to return the integer value.

let big = i64::max_value() as u64 + 10;
let v = sexp!(((a . 64) (b . ,big) (c . 256.0)));

assert!(v["a"].is_i64());

// Greater than i64::MAX.
assert!(!v["b"].is_i64());

// Numbers with a decimal point are not considered integers.
assert!(!v["c"].is_i64());

pub fn is_u64(&self) -> bool

Returns true if the Number is an integer between zero and u64::MAX.

For any Number on which is_u64 returns true, as_u64 is guaranteed to return the integer value.

let v = sexp!(((a . 64) (b . -64) (c . 256.0)));

assert!(v["a"].is_u64());

// Negative integer.
assert!(!v["b"].is_u64());

// Numbers with a decimal point are not considered integers.
assert!(!v["c"].is_u64());

pub fn is_f64(&self) -> bool

Returns true if the Number can be represented by f64.

For any Number on which is_f64 returns true, as_f64 is guaranteed to return the floating point value.

Currently this function returns true if and only if both is_i64 and is_u64 return false but this is not a guarantee in the future.

let v = sexp!(((a . 256.0) (b . 64) (c . -64)));
assert!(v["a"].is_f64());

// Integers.
assert!(!v["b"].is_f64());
assert!(!v["c"].is_f64());

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

If the Number is an integer, represent it as i64 if possible. Returns None otherwise.

let big = i64::max_value() as u64 + 10;
let v = sexp!(((a . 64) (b . ,big) (c . 256.0)));

assert_eq!(v["a"].as_i64(), Some(64));
assert_eq!(v["b"].as_i64(), None);
assert_eq!(v["c"].as_i64(), None);

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

If the Number is an integer, represent it as u64 if possible. Returns None otherwise.

let v = sexp!(((a . 64) (b . -64) (c . 256.0)));

assert_eq!(v["a"].as_u64(), Some(64));
assert_eq!(v["b"].as_u64(), None);
assert_eq!(v["c"].as_u64(), None);

pub fn as_f64(&self) -> Option<f64>

Represents the number as f64 if possible. Returns None otherwise.

let v = sexp!(((a . 256.0) (b . 64) (c . -64)));

assert_eq!(v["a"].as_f64(), Some(256.0));
assert_eq!(v["b"].as_f64(), Some(64.0));
assert_eq!(v["c"].as_f64(), Some(-64.0));

pub fn from_f64(f: f64) -> Option<Number>

Converts a finite f64 to a Number. Infinite or NaN values are not S-expression numbers.

assert!(Number::from_f64(256.0).is_some());

assert!(Number::from_f64(f64::NAN).is_none());

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

Dispatch based on the type of the contained value.

Depending on the stored value, one of the functions of the supplied visitor will be called.

Trait Implementations

impl Clone for Number

fn clone(&self) -> Number

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Number

fn fmt(&self, formatter: &mut Formatter) -> Result

Formats the value using the given formatter.

impl Display for Number

fn fmt(&self, formatter: &mut Formatter) -> Result

Formats the value using the given formatter.

impl From<Number> for Value

fn from(n: Number) -> Self

Performs the conversion.

impl From<f32> for Number

fn from(n: f32) -> Self

Performs the conversion.

impl From<f64> for Number

fn from(n: f64) -> Self

Performs the conversion.

impl From<i16> for Number

fn from(n: i16) -> Self

Performs the conversion.

impl From<i32> for Number

fn from(n: i32) -> Self

Performs the conversion.

impl From<i64> for Number

fn from(n: i64) -> Self

Performs the conversion.

impl From<i8> for Number

fn from(n: i8) -> Self

Performs the conversion.

impl From<u16> for Number

fn from(u: u16) -> Self

Performs the conversion.

impl From<u32> for Number

fn from(u: u32) -> Self

Performs the conversion.

impl From<u64> for Number

fn from(u: u64) -> Self

Performs the conversion.

impl From<u8> for Number

fn from(u: u8) -> Self

Performs the conversion.

impl PartialEq<Number> for Number

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

impl StructuralPartialEq for Number