@tishlang/tish-format 1.0.12 → 2.0.1

package/crates/tish_builtins/src/globals.rs

@@ -0,0 +1,293 @@
+//! Global builtin functions with signature (args: &[Value]) -> Value.
+//!
+//! Used by both tishlang_vm (bytecode) and tishlang_runtime (compiled). Keeps tishlang_vm
+//! independent of tishlang_runtime.
+
+use std::sync::Arc;
+use tishlang_core::VmRef;
+use tishlang_core::{percent_decode, percent_encode, ObjectMap, Value};
+
+/// Boolean(value) - coerce to bool
+pub fn boolean(args: &[Value]) -> Value {
+    let v = args.first().unwrap_or(&Value::Null);
+    Value::Bool(v.is_truthy())
+}
+
+/// decodeURI(str)
+pub fn decode_uri(args: &[Value]) -> Value {
+    let s = args
+        .first()
+        .map(Value::to_display_string)
+        .unwrap_or_default();
+    Value::String(percent_decode(&s).unwrap_or(s).into())
+}
+
+/// encodeURI(str)
+pub fn encode_uri(args: &[Value]) -> Value {
+    let s = args
+        .first()
+        .map(Value::to_display_string)
+        .unwrap_or_default();
+    Value::String(percent_encode(&s).into())
+}
+
+/// isFinite(value)
+pub fn is_finite(args: &[Value]) -> Value {
+    Value::Bool(
+        args.first()
+            .is_some_and(|v| matches!(v, Value::Number(n) if n.is_finite())),
+    )
+}
+
+/// isNaN(value)
+pub fn is_nan(args: &[Value]) -> Value {
+    Value::Bool(args.first().is_none_or(|v| {
+        matches!(v, Value::Number(n) if n.is_nan()) || !matches!(v, Value::Number(_))
+    }))
+}
+
+/// Array.isArray(value)
+pub fn array_is_array(args: &[Value]) -> Value {
+    Value::Bool(matches!(args.first(), Some(Value::Array(_)) | Some(Value::NumberArray(_))))
+}
+
+/// String(value) — convert value to string (JS String constructor as function).
+/// Uses JS `ToString` (arrays comma-join recursively, objects → "[object Object]"),
+/// not the inspect/display form.
+pub fn string_convert(args: &[Value]) -> Value {
+    let v = args.first().unwrap_or(&Value::Null);
+    Value::String(v.to_js_string().into())
+}
+
+/// JS `Number(value)` coercion (ToNumber), issue #36. Numbers pass through; booleans →
+/// 1/0; null → 0; strings parse (trimmed, with `0x`/`0b`/`0o` and `Infinity`, `""` → 0,
+/// otherwise NaN); arrays/objects go via their string form (so `Number([5])` → 5,
+/// `Number([])` → 0, objects → NaN).
+pub fn number_convert(args: &[Value]) -> Value {
+    let v = args.first().unwrap_or(&Value::Null);
+    let n = match v {
+        Value::Number(n) => *n,
+        Value::Bool(b) => {
+            if *b {
+                1.0
+            } else {
+                0.0
+            }
+        }
+        Value::Null => 0.0,
+        Value::String(s) => parse_numeric_string(s),
+        other => parse_numeric_string(&other.to_js_string()),
+    };
+    Value::Number(n)
+}
+
+/// Parse a string as JS `Number` does: trimmed; `""` → 0; `0x`/`0o`/`0b` radix prefixes;
+/// `Infinity`/`-Infinity`; plain decimal/float; anything else → NaN. Public so the
+/// tree-walk interpreter (distinct `Value` type) shares the exact coercion.
+pub fn parse_numeric_string(s: &str) -> f64 {
+    let t = s.trim();
+    if t.is_empty() {
+        return 0.0;
+    }
+    let radix = |rest: &str, r: u32| i64::from_str_radix(rest, r).map(|x| x as f64).unwrap_or(f64::NAN);
+    if let Some(rest) = t.strip_prefix("0x").or_else(|| t.strip_prefix("0X")) {
+        return radix(rest, 16);
+    }
+    if let Some(rest) = t.strip_prefix("0o").or_else(|| t.strip_prefix("0O")) {
+        return radix(rest, 8);
+    }
+    if let Some(rest) = t.strip_prefix("0b").or_else(|| t.strip_prefix("0B")) {
+        return radix(rest, 2);
+    }
+    match t {
+        "Infinity" | "+Infinity" => f64::INFINITY,
+        "-Infinity" => f64::NEG_INFINITY,
+        _ => t.parse::<f64>().unwrap_or(f64::NAN),
+    }
+}
+
+/// String.fromCharCode(...codes)
+pub fn string_from_char_code(args: &[Value]) -> Value {
+    let s: String = args
+        .iter()
+        .filter_map(|v| match v {
+            Value::Number(n) => char::from_u32(*n as u32),
+            _ => None,
+        })
+        .collect();
+    Value::String(s.into())
+}
+
+/// Object.keys(obj)
+pub fn object_keys(args: &[Value]) -> Value {
+    if let Some(Value::Object(obj)) = args.first() {
+        let obj_borrow = obj.borrow();
+        let keys: Vec<Value> = obj_borrow
+            .strings
+            .keys()
+            .map(|k| Value::String(tishlang_core::ArcStr::from(k.as_ref())))
+            .collect();
+        Value::Array(VmRef::new(keys))
+    } else {
+        Value::Array(VmRef::new(Vec::new()))
+    }
+}
+
+/// Object.values(obj)
+pub fn object_values(args: &[Value]) -> Value {
+    if let Some(Value::Object(obj)) = args.first() {
+        let obj_borrow = obj.borrow();
+        let values: Vec<Value> = obj_borrow.strings.values().cloned().collect();
+        Value::Array(VmRef::new(values))
+    } else {
+        Value::Array(VmRef::new(Vec::new()))
+    }
+}
+
+/// Object.entries(obj)
+pub fn object_entries(args: &[Value]) -> Value {
+    if let Some(Value::Object(obj)) = args.first() {
+        let obj_borrow = obj.borrow();
+        let entries: Vec<Value> = obj_borrow
+            .strings
+            .iter()
+            .map(|(k, v)| Value::Array(VmRef::new(vec![Value::String(tishlang_core::ArcStr::from(k.as_ref())), v.clone()])))
+            .collect();
+        Value::Array(VmRef::new(entries))
+    } else {
+        Value::Array(VmRef::new(Vec::new()))
+    }
+}
+
+/// Object.assign(target, ...sources)
+pub fn object_assign(args: &[Value]) -> Value {
+    let target = match args.first() {
+        Some(Value::Object(obj)) => obj,
+        _ => return Value::Null,
+    };
+
+    let additional_capacity: usize = args
+        .iter()
+        .skip(1)
+        .map(|source| {
+            if let Value::Object(src) = source {
+                src.borrow().len_entries()
+            } else {
+                0
+            }
+        })
+        .sum();
+
+    let mut target_mut = target.borrow_mut();
+    target_mut.strings.reserve(additional_capacity);
+
+    for source in args.iter().skip(1) {
+        if let Value::Object(src) = source {
+            let src_borrow = src.borrow();
+            for (k, v) in src_borrow.strings.iter() {
+                target_mut.strings.insert(Arc::clone(k), v.clone());
+            }
+            if let Some(ss) = &src_borrow.symbols {
+                if target_mut.symbols.is_none() {
+                    target_mut.symbols = Some(Default::default());
+                }
+                let dst = target_mut.symbols.as_mut().unwrap();
+                dst.extend(ss.iter().map(|(id, v)| (*id, v.clone())));
+            }
+        }
+    }
+    drop(target_mut);
+    Value::Object(target.clone())
+}
+
+/// parseInt(string, radix?)
+pub fn parse_int(args: &[Value]) -> Value {
+    let s = args
+        .first()
+        .map(Value::to_display_string)
+        .unwrap_or_default();
+    let s = s.trim();
+    let radix = args
+        .get(1)
+        .and_then(|v| match v {
+            Value::Number(n) => Some(*n as i32),
+            _ => None,
+        })
+        .unwrap_or(10);
+
+    if (2..=36).contains(&radix) {
+        let prefix: String = s
+            .chars()
+            .take_while(|c| *c == '-' || *c == '+' || c.is_digit(radix as u32))
+            .collect();
+        if let Ok(n) = i64::from_str_radix(&prefix, radix as u32) {
+            return Value::Number(n as f64);
+        }
+    }
+    Value::Number(f64::NAN)
+}
+
+/// parseFloat(string)
+pub fn parse_float(args: &[Value]) -> Value {
+    let s = args
+        .first()
+        .map(Value::to_display_string)
+        .unwrap_or_default();
+    Value::Number(js_parse_float(&s))
+}
+
+/// JS `parseFloat`: skips leading whitespace, then parses the **longest leading prefix**
+/// that's a valid float (so `parseFloat("3.14abc")` → 3.14, `parseFloat("12.3.4")` → 12.3).
+/// Handles `Infinity`/`-Infinity`; returns NaN when no numeric prefix is present. Issue #36.
+/// Public so the tree-walk interpreter (distinct `Value`) shares the exact behavior.
+pub fn js_parse_float(s: &str) -> f64 {
+    let t = s.trim_start();
+    if t.starts_with("Infinity") || t.starts_with("+Infinity") {
+        return f64::INFINITY;
+    }
+    if t.starts_with("-Infinity") {
+        return f64::NEG_INFINITY;
+    }
+    // Take a generous run of float-shaped chars, then shrink from the right until it parses.
+    let mut end = 0;
+    for (i, c) in t.char_indices() {
+        if c.is_ascii_digit() || matches!(c, '.' | '+' | '-' | 'e' | 'E') {
+            end = i + c.len_utf8();
+        } else {
+            break;
+        }
+    }
+    let mut slice = &t[..end];
+    while !slice.is_empty() {
+        if let Ok(n) = slice.parse::<f64>() {
+            return n;
+        }
+        slice = &slice[..slice.len() - 1];
+    }
+    f64::NAN
+}
+
+/// Object.fromEntries(entries)
+pub fn object_from_entries(args: &[Value]) -> Value {
+    if let Some(Value::Array(entries)) = args.first() {
+        let entries_borrow = entries.borrow();
+        let mut obj: ObjectMap = ObjectMap::with_capacity(entries_borrow.len());
+
+        for entry in entries_borrow.iter() {
+            if let Value::Array(pair) = entry {
+                let pair_borrow = pair.borrow();
+                if pair_borrow.len() >= 2 {
+                    let key: Arc<str> = match &pair_borrow[0] {
+                        Value::String(s) => Arc::from(s.as_str()),
+                        v => v.to_display_string().into(),
+                    };
+                    obj.insert(key, pair_borrow[1].clone());
+                }
+            }
+        }
+
+        Value::object(obj)
+    } else {
+        Value::empty_object()
+    }
+}

package/crates/tish_builtins/src/helpers.rs

@@ -0,0 +1,35 @@
+//! Common helper functions used across builtin implementations.
+
+use std::sync::Arc;
+use tishlang_core::{ObjectMap, Value};
+
+/// Normalize an array index, handling negative indices.
+/// Returns a valid index within bounds or the default value.
+pub fn normalize_index(idx: &Value, len: i64, default: usize) -> usize {
+    match idx {
+        Value::Number(n) => {
+            let n = *n as i64;
+            if n < 0 {
+                (len + n).max(0) as usize
+            } else {
+                n.min(len) as usize
+            }
+        }
+        _ => default,
+    }
+}
+
+/// Create an error object with a single "error" field.
+pub fn make_error_value(e: impl std::fmt::Display) -> Value {
+    let mut obj = ObjectMap::with_capacity(1);
+    obj.insert(Arc::from("error"), Value::String(e.to_string().into()));
+    Value::object(obj)
+}
+
+/// Extract a number from a Value, returning None for non-numbers.
+pub fn extract_num(v: Option<&Value>) -> Option<f64> {
+    v.and_then(|val| match val {
+        Value::Number(n) => Some(*n),
+        _ => None,
+    })
+}

package/crates/tish_builtins/src/iterator.rs

@@ -0,0 +1,129 @@
+//! JS-style iterator objects for `Map`/`Set` (`.values()` / `.keys()` / `.entries()`).
+//!
+//! Like [`crate::collections`] and [`crate::date`], an iterator is a plain `Value::Object`
+//! whose `next` method is a per-instance `Value::native` closure capturing a snapshot of the
+//! items plus a shared position cell — so the one implementation works on every backend with
+//! no new `Value` variant. `next()` returns `{ value, done }`; once exhausted it keeps
+//! returning `{ value: null, done: true }`.
+//!
+//! The runtimes drive iteration through [`tishlang_core::drain_iterator`], which calls `next()`
+//! until `done` — that's how these objects work in `for…of`, spread, and `Array.from`. The
+//! snapshot is taken when the iterator is built (`.values()` is called), matching how the old
+//! array-returning version behaved; mid-iteration mutation of the source is not reflected (a
+//! live iterator is a follow-up).
+
+use std::sync::Arc;
+
+use tishlang_core::{ObjectMap, Value, VmRef};
+
+/// Build a single-use iterator object over `items`: `{ next() -> { value, done } }`.
+pub fn array_iterator(items: Vec<Value>) -> Value {
+    let items: VmRef<Vec<Value>> = VmRef::new(items);
+    let pos: VmRef<usize> = VmRef::new(0);
+
+    let mut m = ObjectMap::default();
+    {
+        // Bulk-drain fast path for `for…of` / spread: return all REMAINING items (from the current
+        // position) as one array and exhaust the iterator — equivalent to calling `next()` until
+        // `done`, but with no per-element `{ value, done }` allocation. `drain_iterator` prefers this
+        // when present; manual `.next()` and partial consumption still work (it respects `pos`).
+        let items = items.clone();
+        let pos = pos.clone();
+        m.insert(
+            Arc::from("__drain__"),
+            Value::native(move |_args: &[Value]| {
+                let i = *pos.borrow();
+                let b = items.borrow();
+                let rest: Vec<Value> = if i < b.len() { b[i..].to_vec() } else { Vec::new() };
+                let len = b.len();
+                drop(b);
+                *pos.borrow_mut() = len;
+                Value::Array(VmRef::new(rest))
+            }),
+        );
+    }
+    {
+        let items = items.clone();
+        let pos = pos.clone();
+        m.insert(
+            Arc::from("next"),
+            Value::native(move |_args: &[Value]| {
+                let i = *pos.borrow();
+                // Read the element (or note exhaustion) without holding the items borrow
+                // across the position write — two different `VmRef`s, but keep it tidy.
+                let (value, done) = {
+                    let b = items.borrow();
+                    if i < b.len() {
+                        (b[i].clone(), false)
+                    } else {
+                        (Value::Null, true)
+                    }
+                };
+                if !done {
+                    *pos.borrow_mut() = i + 1;
+                }
+                let mut r = ObjectMap::default();
+                r.insert(Arc::from("value"), value);
+                r.insert(Arc::from("done"), Value::Bool(done));
+                Value::object(r)
+            }),
+        );
+    }
+    Value::object(m)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn call(obj: &Value, name: &str) -> Value {
+        let Value::Object(o) = obj else { panic!("not an object") };
+        let m = o.borrow().strings.get(name).cloned().expect("method missing");
+        let Value::Function(f) = m else { panic!("{name} is not callable") };
+        f.call(&[])
+    }
+    fn get(obj: &Value, key: &str) -> Value {
+        let Value::Object(o) = obj else { return Value::Null };
+        o.borrow().strings.get(key).cloned().unwrap_or(Value::Null)
+    }
+    fn num(v: &Value) -> f64 {
+        match v {
+            Value::Number(n) => *n,
+            _ => f64::NAN,
+        }
+    }
+    fn nums(v: &Value) -> Vec<f64> {
+        match v {
+            Value::Array(a) => a.borrow().iter().map(num).collect(),
+            _ => vec![],
+        }
+    }
+
+    #[test]
+    fn next_yields_each_then_done() {
+        let it = array_iterator(vec![Value::Number(1.0), Value::Number(2.0)]);
+        let r1 = call(&it, "next");
+        assert_eq!(num(&get(&r1, "value")), 1.0);
+        assert!(!get(&r1, "done").is_truthy());
+        assert_eq!(num(&get(&call(&it, "next"), "value")), 2.0);
+        // exhausted — and it keeps reporting done.
+        assert!(get(&call(&it, "next"), "done").is_truthy());
+        assert!(get(&call(&it, "next"), "done").is_truthy());
+    }
+
+    #[test]
+    fn drain_returns_all_and_exhausts() {
+        let it = array_iterator(vec![Value::Number(1.0), Value::Number(2.0), Value::Number(3.0)]);
+        assert_eq!(nums(&call(&it, "__drain__")), vec![1.0, 2.0, 3.0]);
+        // draining exhausts the iterator (matches calling next() until done).
+        assert!(get(&call(&it, "next"), "done").is_truthy());
+    }
+
+    #[test]
+    fn drain_respects_current_position() {
+        let it = array_iterator(vec![Value::Number(1.0), Value::Number(2.0), Value::Number(3.0)]);
+        call(&it, "next"); // consume the first
+        assert_eq!(nums(&call(&it, "__drain__")), vec![2.0, 3.0]);
+        assert_eq!(nums(&call(&it, "__drain__")), Vec::<f64>::new()); // already drained
+    }
+}

package/crates/tish_builtins/src/lib.rs

@@ -0,0 +1,21 @@
+//! Shared builtin implementations for Tish.
+//!
+//! Used by the compiled runtime (tishlang_runtime) and bytecode VM (tishlang_vm). The
+//! interpreter (tishlang_eval) implements builtins inline due to different Value
+//! and native signatures.
+
+pub mod array;
+pub mod collections;
+pub mod construct;
+pub mod date;
+pub mod globals;
+pub mod helpers;
+pub mod iterator;
+pub mod math;
+pub mod number;
+pub mod object;
+pub mod string;
+pub mod symbol;
+pub mod typedarrays;
+
+pub use tishlang_core::Value;

package/crates/tish_builtins/src/math.rs

@@ -0,0 +1,89 @@
+//! Math builtin functions.
+
+use crate::helpers::extract_num;
+use tishlang_core::Value;
+
+macro_rules! math_unary {
+    ($name:ident, $op:ident) => {
+        pub fn $name(args: &[Value]) -> Value {
+            let n = extract_num(args.first()).unwrap_or(f64::NAN);
+            Value::Number(n.$op())
+        }
+    };
+}
+
+math_unary!(abs, abs);
+math_unary!(sqrt, sqrt);
+math_unary!(floor, floor);
+math_unary!(ceil, ceil);
+math_unary!(round, round);
+math_unary!(sin, sin);
+math_unary!(cos, cos);
+math_unary!(tan, tan);
+math_unary!(asin, asin);
+math_unary!(acos, acos);
+math_unary!(atan, atan);
+math_unary!(log, ln);
+math_unary!(log10, log10);
+math_unary!(log2, log2);
+math_unary!(exp, exp);
+math_unary!(trunc, trunc);
+math_unary!(cbrt, cbrt);
+
+pub fn min(args: &[Value]) -> Value {
+    let n = args
+        .iter()
+        .filter_map(|v| extract_num(Some(v)))
+        .fold(f64::INFINITY, f64::min);
+    Value::Number(if n == f64::INFINITY { f64::NAN } else { n })
+}
+
+pub fn max(args: &[Value]) -> Value {
+    let n = args
+        .iter()
+        .filter_map(|v| extract_num(Some(v)))
+        .fold(f64::NEG_INFINITY, f64::max);
+    Value::Number(if n == f64::NEG_INFINITY { f64::NAN } else { n })
+}
+
+pub fn pow(args: &[Value]) -> Value {
+    let base = extract_num(args.first()).unwrap_or(f64::NAN);
+    let exp = extract_num(args.get(1)).unwrap_or(f64::NAN);
+    Value::Number(base.powf(exp))
+}
+
+pub fn random(_args: &[Value]) -> Value {
+    Value::Number(rand::random::<f64>())
+}
+
+pub fn sign(args: &[Value]) -> Value {
+    let n = extract_num(args.first()).unwrap_or(f64::NAN);
+    Value::Number(if n.is_nan() {
+        f64::NAN
+    } else if n > 0.0 {
+        1.0
+    } else if n < 0.0 {
+        -1.0
+    } else {
+        0.0
+    })
+}
+
+pub fn atan2(args: &[Value]) -> Value {
+    let y = extract_num(args.first()).unwrap_or(f64::NAN);
+    let x = extract_num(args.get(1)).unwrap_or(f64::NAN);
+    Value::Number(y.atan2(x))
+}
+
+pub fn hypot(args: &[Value]) -> Value {
+    let x = extract_num(args.first()).unwrap_or(0.0);
+    let y = extract_num(args.get(1)).unwrap_or(0.0);
+    Value::Number(x.hypot(y))
+}
+
+/// ES6 `Math.imul`: 32-bit integer multiply (used by xmur3 PRNG in juke-cards).
+pub fn imul(args: &[Value]) -> Value {
+    let a = extract_num(args.first()).unwrap_or(0.0) as i32;
+    let b = extract_num(args.get(1)).unwrap_or(0.0) as i32;
+    Value::Number(a.wrapping_mul(b) as f64)
+}

package/crates/tish_builtins/src/number.rs

@@ -0,0 +1,96 @@
+//! Number builtin methods.
+//!
+//! Canonical, backend-agnostic implementations of `Number.prototype` methods.
+//! The VM (`get_member`), the Rust runtime (`tishlang_runtime::number_to_fixed`),
+//! and the tree-walk interpreter all route through here so every backend produces
+//! byte-identical output — see `tish/docs/full-backend-parity-plan.md` (Workstream A).
+
+use tishlang_core::Value;
+
+/// `Number.prototype.toFixed(digits)` — ECMA-262 §21.1.3.3.
+///
+/// Formats the number using fixed-point notation with `digits` fraction digits.
+/// `digits` is clamped to 0–20 (ECMA range) and defaults to 0 when absent/non-numeric,
+/// matching `(1.5).toFixed() === "2"`. A non-number receiver yields `"NaN"`.
+pub fn to_fixed(n: &Value, digits: &Value) -> Value {
+    let num = match n {
+        Value::Number(x) => *x,
+        _ => f64::NAN,
+    };
+    let d = match digits {
+        Value::Number(x) => (*x as i32).clamp(0, 20),
+        _ => 0,
+    } as usize;
+    Value::String(format!("{:.*}", d, num).into())
+}
+
+/// `Number.prototype.toString([radix])` — ECMA-262 §21.1.3.6.
+///
+/// Radix defaults to 10 (canonical JS number formatting). For radix 2–36 the value is
+/// rendered in that base: sign, integer part via repeated division, and a fractional part
+/// (bounded to 52 digits, like V8). NaN / ±Infinity stringify as in base 10 regardless of
+/// radix. An out-of-range radix yields `"RadixError"` so the caller can surface a RangeError.
+pub fn to_string(n: &Value, radix: &Value) -> Value {
+    let num = match n {
+        Value::Number(x) => *x,
+        _ => f64::NAN,
+    };
+    let r = match radix {
+        Value::Number(x) => *x as i64,
+        _ => 10,
+    };
+    match number_to_string_radix(num, r) {
+        Some(s) => Value::String(s.into()),
+        None => Value::String("RadixError".into()),
+    }
+}
+
+/// Backend-agnostic core of `Number.prototype.toString`: works on a plain `f64` so the
+/// tree-walk interpreter (whose `Value` is a distinct type) can share the exact same
+/// formatting. Returns `None` for an out-of-range radix (caller surfaces a RangeError).
+pub fn number_to_string_radix(num: f64, radix: i64) -> Option<String> {
+    if !(2..=36).contains(&radix) {
+        return None;
+    }
+    if radix == 10 || num.is_nan() || num.is_infinite() {
+        return Some(tishlang_core::js_number_to_string(num));
+    }
+    let radix = radix as u32;
+    const DIGITS: &[u8] = b"0123456789abcdefghijklmnopqrstuvwxyz";
+    let negative = num < 0.0;
+    let value = num.abs();
+    let int_part = value.trunc();
+    let mut frac = value - int_part;
+
+    // Integer part: collect base-`radix` digits least-significant first, then reverse.
+    let mut int_digits = Vec::new();
+    let mut i = int_part;
+    if i == 0.0 {
+        int_digits.push(b'0');
+    }
+    while i >= 1.0 {
+        let d = (i % radix as f64) as usize;
+        int_digits.push(DIGITS[d]);
+        i = (i / radix as f64).trunc();
+    }
+    int_digits.reverse();
+    let mut out = String::with_capacity(int_digits.len() + 2);
+    if negative {
+        out.push('-');
+    }
+    out.push_str(std::str::from_utf8(&int_digits).unwrap());
+
+    // Fractional part: multiply-by-radix, emitting the integer overflow each step.
+    if frac > 0.0 {
+        out.push('.');
+        let mut count = 0;
+        while frac > 0.0 && count < 52 {
+            frac *= radix as f64;
+            let d = frac.trunc() as usize;
+            out.push(DIGITS[d] as char);
+            frac -= frac.trunc();
+            count += 1;
+        }
+    }
+    Some(out)
+}