Skip to main content

vibe/stdlib_v2/num_and_autodiff/
mod.rs

1//! VibeScript v0.02 Standard Library — Strict Numeric Parsers, Exact Decimal Math,
2//! Euclidean/Checked Arithmetic, Seeded SplitMix64 PRNG & Forward-Mode Autodiff.
3
4pub mod autodiff;
5pub mod decimal;
6pub mod math_ext;
7
8use crate::error::{DiagCode, Diagnostic};
9use crate::span::Span;
10use crate::value::Value;
11
12/// All stdlib v0.02 bindings provided by `num_and_autodiff`.
13pub const NUM_AND_AUTODIFF_BINDINGS: &[&str] = &[
14    // Strict non-coercing numeric parsers (§9)
15    "num.parse_i64",
16    "num.parse_u64",
17    "num.parse_f64",
18    // Exact base-10 Decimal math (§2, §11)
19    "decimal.from_str",
20    "decimal.from_parts",
21    "decimal.add",
22    "decimal.sub",
23    "decimal.mul",
24    "decimal.div",
25    "decimal.round",
26    "decimal.to_fixed",
27    "decimal.eq",
28    "decimal.cmp",
29    // Euclidean, checked, saturating & compensated math (§11, §22)
30    "math.idiv",
31    "math.imod",
32    "math.divmod",
33    "math.gcd",
34    "math.lcm",
35    "math.lerp",
36    "math.sum_precise",
37    "math.min_list",
38    "math.max_list",
39    "math.add_checked",
40    "math.sub_checked",
41    "math.mul_checked",
42    "math.add_saturating",
43    "math.sub_saturating",
44    "math.mul_saturating",
45    "math.round_mode",
46    // Deterministic seeded SplitMix64 PRNG (§6, §11)
47    "math.prng_seed",
48    "math.prng_next_u64",
49    "math.prng_next_f64",
50    "math.prng_range",
51    // First-class forward-mode Automatic Differentiation (§16)
52    "autodiff.dual",
53    "autodiff.dual_add",
54    "autodiff.dual_sub",
55    "autodiff.dual_mul",
56    "autodiff.dual_div",
57    "autodiff.dual_sin",
58    "autodiff.dual_cos",
59    "autodiff.dual_exp",
60    "autodiff.dual_pow",
61    "autodiff.value_and_grad",
62    "autodiff.grad",
63    "autodiff.jacobian",
64];
65
66/// Route a `num.*`, `decimal.*`, `math.*`, or `autodiff.*` call.
67pub fn call_num_and_autodiff(
68    path: &str,
69    args: &[Value],
70    span: Span,
71) -> Result<Option<Value>, Diagnostic> {
72    if let Some(v) = decimal::call_decimal(path, args, span)? {
73        return Ok(Some(v));
74    }
75    if let Some(v) = math_ext::call_math_ext(path, args, span)? {
76        return Ok(Some(v));
77    }
78    autodiff::call_autodiff(path, args, span)
79}
80
81pub(crate) fn extract_str(
82    args: &[Value],
83    idx: usize,
84    ctx: &str,
85    span: Span,
86) -> Result<String, Diagnostic> {
87    match args.get(idx) {
88        Some(Value::String(s)) | Some(Value::Iri(s)) => Ok(s.clone()),
89        _ => Err(Diagnostic::new(
90            DiagCode::E100,
91            span,
92            format!("{ctx}: argument #{idx} must be a String"),
93        )),
94    }
95}
96
97pub(crate) fn extract_i64(
98    args: &[Value],
99    idx: usize,
100    ctx: &str,
101    span: Span,
102) -> Result<i64, Diagnostic> {
103    args.get(idx).and_then(Value::as_i64).ok_or_else(|| {
104        Diagnostic::new(
105            DiagCode::E100,
106            span,
107            format!("{ctx}: argument #{idx} must be an I64"),
108        )
109    })
110}
111
112pub(crate) fn extract_f64(
113    args: &[Value],
114    idx: usize,
115    ctx: &str,
116    span: Span,
117) -> Result<f64, Diagnostic> {
118    args.get(idx).and_then(Value::as_f64).ok_or_else(|| {
119        Diagnostic::new(
120            DiagCode::E100,
121            span,
122            format!("{ctx}: argument #{idx} must be a number"),
123        )
124    })
125}
126
127pub(crate) fn extract_list(
128    args: &[Value],
129    idx: usize,
130    ctx: &str,
131    span: Span,
132) -> Result<Vec<Value>, Diagnostic> {
133    match args.get(idx) {
134        Some(Value::List(items)) => Ok(items.clone()),
135        _ => Err(Diagnostic::new(
136            DiagCode::E100,
137            span,
138            format!("{ctx}: argument #{idx} must be a List"),
139        )),
140    }
141}
142
143pub(crate) fn opt_i64(args: &[Value], idx: usize, default: i64) -> i64 {
144    args.get(idx).and_then(Value::as_i64).unwrap_or(default)
145}
146
147pub(crate) fn opt_str(args: &[Value], idx: usize, default: &str) -> String {
148    match args.get(idx) {
149        Some(Value::String(s)) | Some(Value::Iri(s)) => s.clone(),
150        _ => default.to_string(),
151    }
152}