Struct Number 

pub struct Number(/* private fields */);

A JavaScript number: an f64 that holds one NaN.

FunctionalScript has one NaN: nothing in the language tells two apart, so a sign or payload a host operation left on one — -NaN flips the sign, x86’s 0 / 0 sets it — is dropped where an f64 becomes a Number, and every operator’s result passes back through the same conversion. The field is private, so there is no other way to build one, and a NaN-boxing VM, which keeps its boxed values in the negative quiet NaNs, can store the bits as they are.

This is the VM’s number: a literal or a parsed string becomes one once, and the VM computes on it from there — the ECMAScript operations on a Number are its methods and operators. An f64 is read back out only where a leaf needs IEEE 754 arithmetic Rust already has, and at a test’s edge to look at the bits.

PartialOrd is IEEE 754’s: a NaN compares with nothing, which is exactly the undefined a relational operator’s abstract comparison answers.

Implementations

impl Number

pub fn decompose(self) -> Option<(Sign, u64, i32)>

self as ±significand · 2^exponent, exactly: a normal value’s significand has the implicit leading bit folded in, a subnormal’s is the fraction as it is, and both zeros are a 0 significand with their own sign. None for a NaN and the infinities.

Not reduced to lowest terms: significand may end in zero bits.

impl Number

pub fn to_int32(self) -> i32

ToInt32. https://tc39.es/ecma262/#sec-toint32

pub fn to_uint32(self) -> u32

ToUint32. https://tc39.es/ecma262/#sec-touint32 — used by <</>> (for the shift-count operand) and >>> (for both operands, since it has no signed form).

impl Number

pub fn pow(self, exponent: Self) -> Self

Math.pow(self, exponent), which is self ** exponent: the spec’s Number::exponentiate. Diverges from f64::powf (and C99’s pow, which powf follows) in exactly two spots: a NaN exponent is NaN regardless of the base (C99 special-cases pow(1, y) = 1 even for a NaN y), and an infinite exponent against a base of magnitude 1 is NaN (C99 gives pow(±1, ±∞) = 1). Every other case — zero/infinite base or exponent, the sign and parity rules, a negative base with a non-integer exponent giving NaN — already matches powf exactly, so only these two get a special case. Not a core::ops trait — Rust has no operator for exponentiation — so a plain method, the same as BigInt::pow and Any::pow.

impl Number

pub fn to_integer_or_infinity(self) -> Number

ToIntegerOrInfinity (https://tc39.es/ecma262/#sec-tointegerorinfinity) of a number: NaN and either zero are 0, an infinity is itself, and everything else is truncated toward zero. The specification’s answer is a mathematical value, so a -0 never comes out of it: -0.5 truncates to 0, not -0, and the addition below is what folds the sign — -0.0 + 0.0 is 0.0 in IEEE 754.

impl Number

The names are JavaScript’s, in Rust’s casing: Number.NaN is NAN, Number.isFinite is is_finite, and each does what its original does.

pub const NAN: Self

Number.NaN — the one NaN: quiet, positive, empty payload.

pub fn is_nan(self) -> bool

Number.isNaN(self).

pub fn is_finite(self) -> bool

Number.isFinite(self): neither a NaN nor an infinity.

Trait Implementations

impl Add for Number

type Output = Number

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self

Performs the + operation.

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

The bare f64, as every other Unpacked payload prints bare: a numeric Any reads 1.0, not Number(1.0), in a test’s failure message.

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

Formats the value using the given formatter.

impl Div for Number

type Output = Number

The resulting type after applying the / operator.

fn div(self, rhs: Self) -> Self

Performs the / operation.

impl<A: IVm> From<Number> for Unpacked<A>

fn from(value: Number) -> Self

Converts to this type from the input type.

impl From<Number> for f64

fn from(v: Number) -> Self

Converts to this type from the input type.

impl From<bool> for Number

Number(true) is 1 and Number(false) is 0: ToNumber of a boolean.

fn from(v: bool) -> Self

Converts to this type from the input type.

impl From<f64> for Number

The one way in: every NaN becomes Number::NAN, everything else keeps its bits.

fn from(v: f64) -> Self

Converts to this type from the input type.

impl From<i32> for Number

Exact: every i32 is a Number. ToInt32’s results come back this way.

fn from(v: i32) -> Self

Converts to this type from the input type.

impl From<u32> for Number

Exact: every u32 is a Number. ToUint32’s results come back this way.

fn from(v: u32) -> Self

Converts to this type from the input type.

impl Mul for Number

type Output = Number

The resulting type after applying the * operator.

fn mul(self, rhs: Self) -> Self

Performs the * operation.

impl Neg for Number

type Output = Number

The resulting type after applying the - operator.

fn neg(self) -> Self

Performs the unary - operation.

impl PartialEq for Number

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

Equality operator ==.

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

Inequality operator !=.

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

type Output = Number

The resulting type after applying the % operator.

fn rem(self, rhs: Self) -> Self

Performs the % operation.

impl StructuralPartialEq for Number

impl Sub for Number

type Output = Number

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self

Performs the - operation.

impl<A: IVm> TryFrom<Any<A>> for Number

type Error = Any<A>

The type returned in the event of a conversion error.

fn try_from(value: Any<A>) -> Result<Self, Self::Error>

Performs the conversion.