Enum Value

Source

pub enum Value {
    UnsignedInt(u64),
    UnsignedBigInt(u128),
    SignedInt(i64),
    SignedBigInt(i128),
    Float(f64),
}

Expand description

A numeric value.

Every calculation is parsed calculated as a common value type. This type can be concretely represented by one of a number of memory formats.

§Value Orders

The order of a value is jargon for its in-memory representation. The orders currently available are:

u64
u128
i64
i128
f64

Note that in general, lower orders have a narrower scope and higher orders have a broader scope. This enables us to promote values to higher compatible orders as necessary.

§Promotion

It will sometimes be necessary to promote a value. The next order after a promotion depends on the value in question. It follows these rules:

u64 values are unconditionally promoted to u128 as that conversion is infallible
u128 values are promoted to the next order in sequence which can represent the type, according to whether or not it fits inside the type bounds.

I.e. the value u64::MAX would be promoted to i128, skipping i64, as it could not be losslessly converted. The value i128::MAX + 1 would be promoted to f64, even though this will lose precision, because f64 can better approximate that overflow than i128 could.
i64 values are unconditionally promoted to i128 as that conversion is infallible.
i128 values are unconditionally promoted to f64 as that type can better approximate very large values.
f64 values remain f64.

§Parsing Rules

When parsing a value, each order is checked in sequence. The first value type which parses without error is used.

§Math Rules

When computing an expression, for each pair of values, this algorithm is applied:

the lower-order of the pair is promoted
if the two orders are still not equal, the previous step is repeated
once the two orders are equal, math is performed as normal.

§Equality and Comparison

Equality and comparison operations are defined on the logical values. This is to say that when testing equality or comparing values, they are promoted until they match, and then the appropriate calculation is performed.

For strict equality comparisons, use the strict_eq method. For strict ordering, use the strict_cmp method.

Variants§

§

Enum Value Copy item path

§Value Orders

§Promotion

§Parsing Rules

§Math Rules

§Equality and Comparison

Variants§

UnsignedInt(u64)

UnsignedBigInt(u128)

SignedInt(i64)

SignedBigInt(i128)

Float(f64)

Implementations§

impl Value

pub fn rotate_left(self, shift: impl Into<Value>) -> Result<Value, Error>

pub fn rotate_right(self, shift: impl Into<Value>) -> Result<Value, Error>

impl Value

pub fn strict_eq(self, other: Self) -> bool

pub fn strict_cmp(self, other: Self) -> Ordering

impl Value

pub fn trunc_div(self, other: impl Into<Self>) -> Self

pub fn pow(self, right: impl Into<Value>) -> Result<Value, Error>

pub fn abs(self) -> Value

pub fn ceil(self) -> Value

pub fn floor(self) -> Value

pub fn round(self) -> Value

pub fn sin(self) -> Value

pub fn cos(self) -> Value

pub fn tan(self) -> Value

pub fn sinh(self) -> Value

pub fn cosh(self) -> Value

pub fn tanh(self) -> Value

pub fn asin(self) -> Value

pub fn acos(self) -> Value

pub fn atan(self) -> Value

pub fn asinh(self) -> Value

pub fn acosh(self) -> Value

pub fn atanh(self) -> Value

pub fn rad(self) -> Value

pub fn deg(self) -> Value

pub fn sqrt(self) -> Value

pub fn cbrt(self) -> Value

pub fn log(self) -> Value

pub fn lg(self) -> Value

pub fn ln(self) -> Value

pub fn exp(self) -> Value

impl Value

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

pub fn parse_binary(s: &str) -> Result<Self, ParseValueError>

pub fn parse_octal(s: &str) -> Result<Self, ParseValueError>

pub fn parse_decimal(s: &str) -> Result<Self, ParseValueError>

pub fn parse_hex(s: &str) -> Result<Self, ParseValueError>

impl Value

pub const PI: Self

pub const E: Self

Trait Implementations§

impl<Rhs> Add<Rhs> for Valuewhere Rhs: Into<Value>,

type Output = Value

fn add(self, rhs: Rhs) -> Value

impl<Rhs> AddAssign<Rhs> for Valuewhere Rhs: Into<Value>,

fn add_assign(&mut self, rhs: Rhs)

impl Binary for Value

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

impl<Rhs> BitAnd<Rhs> for Valuewhere Rhs: Into<Value>,

type Output = Result<Value, Error>

fn bitand(self, rhs: Rhs) -> Self::Output

impl<Rhs> BitOr<Rhs> for Valuewhere Rhs: Into<Value>,

type Output = Result<Value, Error>

fn bitor(self, rhs: Rhs) -> Self::Output

impl<Rhs> BitXor<Rhs> for Valuewhere Rhs: Into<Value>,

type Output = Result<Value, Error>

fn bitxor(self, rhs: Rhs) -> Self::Output

impl Clone for Value

fn clone(&self) -> Value

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

impl Debug for Value

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

impl Display for Value

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

impl<Rhs> Div<Rhs> for Valuewhere Rhs: Into<Value>,

Enum Value

impl<Rhs> Add<Rhs> for Value
where Rhs: Into<Value>,

impl<Rhs> AddAssign<Rhs> for Value
where Rhs: Into<Value>,

impl<Rhs> BitAnd<Rhs> for Value
where Rhs: Into<Value>,

impl<Rhs> BitOr<Rhs> for Value
where Rhs: Into<Value>,

impl<Rhs> BitXor<Rhs> for Value
where Rhs: Into<Value>,

impl<Rhs> Div<Rhs> for Value
where Rhs: Into<Value>,

impl<Rhs> DivAssign<Rhs> for Value
where Rhs: Into<Value>,

impl<Rhs> Mul<Rhs> for Value
where Rhs: Into<Value>,

impl<Rhs> MulAssign<Rhs> for Value
where Rhs: Into<Value>,