ion_core/
stdlib.rs

1//! Built-in standard library modules.
2//!
3//! These modules are automatically registered in every Engine instance
4//! and provide namespaced access to common functions and constants.
5//! The same functions remain available as top-level builtins for
6//! backwards compatibility.
7
8use crate::module::Module;
9use crate::value::Value;
10
11/// Build the `math` stdlib module.
12///
13/// Functions: abs, min, max, floor, ceil, round, sqrt, pow, clamp, log, log2, log10, sin, cos, tan, atan2
14/// Constants: PI, E, INF, NAN, TAU
15pub fn math_module() -> Module {
16    let mut m = Module::new("math");
17
18    // Constants
19    m.set("PI", Value::Float(std::f64::consts::PI));
20    m.set("E", Value::Float(std::f64::consts::E));
21    m.set("TAU", Value::Float(std::f64::consts::TAU));
22    m.set("INF", Value::Float(f64::INFINITY));
23    m.set("NAN", Value::Float(f64::NAN));
24
25    m.register_fn("abs", |args: &[Value]| {
26        if args.len() != 1 {
27            return Err(ion_str!("math::abs takes 1 argument"));
28        }
29        match &args[0] {
30            Value::Int(n) => Ok(Value::Int(n.abs())),
31            Value::Float(n) => Ok(Value::Float(n.abs())),
32            _ => Err(format!(
33                "{}{}",
34                ion_str!("math::abs not supported for "),
35                args[0].type_name()
36            )),
37        }
38    });
39
40    m.register_fn("min", |args: &[Value]| {
41        if args.len() < 2 {
42            return Err(ion_str!("math::min requires at least 2 arguments"));
43        }
44        let mut best = args[0].clone();
45        for arg in &args[1..] {
46            match (&best, arg) {
47                (Value::Int(a), Value::Int(b)) if b < a => best = arg.clone(),
48                (Value::Float(a), Value::Float(b)) if b < a => best = arg.clone(),
49                (Value::Int(a), Value::Float(b)) if *b < (*a as f64) => best = arg.clone(),
50                (Value::Float(a), Value::Int(b)) if (*b as f64) < *a => best = arg.clone(),
51                (Value::Int(_), Value::Int(_))
52                | (Value::Float(_), Value::Float(_))
53                | (Value::Int(_), Value::Float(_))
54                | (Value::Float(_), Value::Int(_)) => {}
55                _ => return Err(ion_str!("math::min requires numeric arguments")),
56            }
57        }
58        Ok(best)
59    });
60
61    m.register_fn("max", |args: &[Value]| {
62        if args.len() < 2 {
63            return Err(ion_str!("math::max requires at least 2 arguments"));
64        }
65        let mut best = args[0].clone();
66        for arg in &args[1..] {
67            match (&best, arg) {
68                (Value::Int(a), Value::Int(b)) if b > a => best = arg.clone(),
69                (Value::Float(a), Value::Float(b)) if b > a => best = arg.clone(),
70                (Value::Int(a), Value::Float(b)) if *b > (*a as f64) => best = arg.clone(),
71                (Value::Float(a), Value::Int(b)) if (*b as f64) > *a => best = arg.clone(),
72                (Value::Int(_), Value::Int(_))
73                | (Value::Float(_), Value::Float(_))
74                | (Value::Int(_), Value::Float(_))
75                | (Value::Float(_), Value::Int(_)) => {}
76                _ => return Err(ion_str!("math::max requires numeric arguments")),
77            }
78        }
79        Ok(best)
80    });
81
82    m.register_fn("floor", |args: &[Value]| match &args[0] {
83        Value::Float(n) => Ok(Value::Float(n.floor())),
84        Value::Int(n) => Ok(Value::Int(*n)),
85        _ => Err(format!(
86            "{}{}",
87            ion_str!("math::floor not supported for "),
88            args[0].type_name()
89        )),
90    });
91
92    m.register_fn("ceil", |args: &[Value]| match &args[0] {
93        Value::Float(n) => Ok(Value::Float(n.ceil())),
94        Value::Int(n) => Ok(Value::Int(*n)),
95        _ => Err(format!(
96            "{}{}",
97            ion_str!("math::ceil not supported for "),
98            args[0].type_name()
99        )),
100    });
101
102    m.register_fn("round", |args: &[Value]| match &args[0] {
103        Value::Float(n) => Ok(Value::Float(n.round())),
104        Value::Int(n) => Ok(Value::Int(*n)),
105        _ => Err(format!(
106            "{}{}",
107            ion_str!("math::round not supported for "),
108            args[0].type_name()
109        )),
110    });
111
112    m.register_fn("sqrt", |args: &[Value]| {
113        let n = args[0]
114            .as_float()
115            .ok_or(ion_str!("math::sqrt requires a number"))?;
116        Ok(Value::Float(n.sqrt()))
117    });
118
119    m.register_fn("pow", |args: &[Value]| {
120        if args.len() != 2 {
121            return Err(ion_str!("math::pow takes 2 arguments"));
122        }
123        match (&args[0], &args[1]) {
124            (Value::Int(base), Value::Int(exp)) => {
125                if *exp >= 0 {
126                    Ok(Value::Int(base.pow(*exp as u32)))
127                } else {
128                    Ok(Value::Float((*base as f64).powi(*exp as i32)))
129                }
130            }
131            _ => {
132                let b = args[0]
133                    .as_float()
134                    .ok_or(ion_str!("math::pow requires numeric arguments"))?;
135                let e = args[1]
136                    .as_float()
137                    .ok_or(ion_str!("math::pow requires numeric arguments"))?;
138                Ok(Value::Float(b.powf(e)))
139            }
140        }
141    });
142
143    m.register_fn("clamp", |args: &[Value]| {
144        if args.len() != 3 {
145            return Err(ion_str!("math::clamp requires 3 arguments: value, min, max"));
146        }
147        match (&args[0], &args[1], &args[2]) {
148            (Value::Int(v), Value::Int(lo), Value::Int(hi)) => Ok(Value::Int(*v.max(lo).min(hi))),
149            (Value::Float(v), Value::Float(lo), Value::Float(hi)) => {
150                Ok(Value::Float(v.max(*lo).min(*hi)))
151            }
152            _ => {
153                let v = args[0]
154                    .as_float()
155                    .ok_or(ion_str!("math::clamp requires numeric arguments"))?;
156                let lo = args[1]
157                    .as_float()
158                    .ok_or(ion_str!("math::clamp requires numeric arguments"))?;
159                let hi = args[2]
160                    .as_float()
161                    .ok_or(ion_str!("math::clamp requires numeric arguments"))?;
162                Ok(Value::Float(v.max(lo).min(hi)))
163            }
164        }
165    });
166
167    // Trigonometry
168    m.register_fn("sin", |args: &[Value]| {
169        let n = args[0]
170            .as_float()
171            .ok_or(ion_str!("math::sin requires a number"))?;
172        Ok(Value::Float(n.sin()))
173    });
174
175    m.register_fn("cos", |args: &[Value]| {
176        let n = args[0]
177            .as_float()
178            .ok_or(ion_str!("math::cos requires a number"))?;
179        Ok(Value::Float(n.cos()))
180    });
181
182    m.register_fn("tan", |args: &[Value]| {
183        let n = args[0]
184            .as_float()
185            .ok_or(ion_str!("math::tan requires a number"))?;
186        Ok(Value::Float(n.tan()))
187    });
188
189    m.register_fn("atan2", |args: &[Value]| {
190        if args.len() != 2 {
191            return Err(ion_str!("math::atan2 takes 2 arguments"));
192        }
193        let y = args[0]
194            .as_float()
195            .ok_or(ion_str!("math::atan2 requires numeric arguments"))?;
196        let x = args[1]
197            .as_float()
198            .ok_or(ion_str!("math::atan2 requires numeric arguments"))?;
199        Ok(Value::Float(y.atan2(x)))
200    });
201
202    // Logarithms
203    m.register_fn("log", |args: &[Value]| {
204        let n = args[0]
205            .as_float()
206            .ok_or(ion_str!("math::log requires a number"))?;
207        Ok(Value::Float(n.ln()))
208    });
209
210    m.register_fn("log2", |args: &[Value]| {
211        let n = args[0]
212            .as_float()
213            .ok_or(ion_str!("math::log2 requires a number"))?;
214        Ok(Value::Float(n.log2()))
215    });
216
217    m.register_fn("log10", |args: &[Value]| {
218        let n = args[0]
219            .as_float()
220            .ok_or(ion_str!("math::log10 requires a number"))?;
221        Ok(Value::Float(n.log10()))
222    });
223
224    // Rounding/check
225    m.register_fn("is_nan", |args: &[Value]| match &args[0] {
226        Value::Float(n) => Ok(Value::Bool(n.is_nan())),
227        Value::Int(_) => Ok(Value::Bool(false)),
228        _ => Err(format!(
229            "{}{}",
230            ion_str!("math::is_nan not supported for "),
231            args[0].type_name()
232        )),
233    });
234
235    m.register_fn("is_inf", |args: &[Value]| match &args[0] {
236        Value::Float(n) => Ok(Value::Bool(n.is_infinite())),
237        Value::Int(_) => Ok(Value::Bool(false)),
238        _ => Err(format!(
239            "{}{}",
240            ion_str!("math::is_inf not supported for "),
241            args[0].type_name()
242        )),
243    });
244
245    m
246}
247
248/// Build the `json` stdlib module.
249///
250/// Functions: encode, decode, pretty
251pub fn json_module() -> Module {
252    let mut m = Module::new("json");
253
254    m.register_fn("encode", |args: &[Value]| {
255        if args.len() != 1 {
256            return Err(ion_str!("json::encode takes 1 argument"));
257        }
258        let json = args[0].to_json();
259        Ok(Value::Str(json.to_string()))
260    });
261
262    m.register_fn("decode", |args: &[Value]| {
263        if args.len() != 1 {
264            return Err(ion_str!("json::decode takes 1 argument"));
265        }
266        let s = args[0]
267            .as_str()
268            .ok_or_else(|| ion_str!("json::decode requires a string"))?;
269        let json: serde_json::Value = serde_json::from_str(s)
270            .map_err(|e| format!("{}{}", ion_str!("json::decode error: "), e))?;
271        Ok(Value::from_json(json))
272    });
273
274    m.register_fn("pretty", |args: &[Value]| {
275        if args.len() != 1 {
276            return Err(ion_str!("json::pretty takes 1 argument"));
277        }
278        let json = args[0].to_json();
279        serde_json::to_string_pretty(&json)
280            .map(Value::Str)
281            .map_err(|e| format!("{}{}", ion_str!("json::pretty error: "), e))
282    });
283
284    #[cfg(feature = "msgpack")]
285    m.register_fn("msgpack_encode", |args: &[Value]| {
286        if args.len() != 1 {
287            return Err(ion_str!("json::msgpack_encode takes 1 argument"));
288        }
289        args[0].to_msgpack().map(Value::Bytes)
290    });
291
292    #[cfg(feature = "msgpack")]
293    m.register_fn("msgpack_decode", |args: &[Value]| {
294        if args.len() != 1 {
295            return Err(ion_str!("json::msgpack_decode takes 1 argument"));
296        }
297        let data = match &args[0] {
298            Value::Bytes(b) => b,
299            _ => return Err(ion_str!("json::msgpack_decode requires bytes")),
300        };
301        Value::from_msgpack(data)
302    });
303
304    m
305}
306
307/// Build the `io` stdlib module.
308///
309/// Functions: print, println, input (placeholder)
310pub fn io_module() -> Module {
311    let mut m = Module::new("io");
312
313    m.register_fn("print", |args: &[Value]| {
314        let parts: Vec<String> = args.iter().map(|a| a.to_string()).collect();
315        print!("{}", parts.join(" "));
316        Ok(Value::Unit)
317    });
318
319    m.register_fn("println", |args: &[Value]| {
320        let parts: Vec<String> = args.iter().map(|a| a.to_string()).collect();
321        println!("{}", parts.join(" "));
322        Ok(Value::Unit)
323    });
324
325    m.register_fn("eprintln", |args: &[Value]| {
326        let parts: Vec<String> = args.iter().map(|a| a.to_string()).collect();
327        eprintln!("{}", parts.join(" "));
328        Ok(Value::Unit)
329    });
330
331    m
332}
333
334/// Build the `str` stdlib module.
335///
336/// Functions: join
337pub fn string_module() -> Module {
338    let mut m = Module::new("string");
339
340    m.register_fn("join", |args: &[Value]| {
341        if args.is_empty() || args.len() > 2 {
342            return Err(ion_str!("string::join requires 1-2 arguments: list, [separator]"));
343        }
344        let items = match &args[0] {
345            Value::List(items) => items,
346            _ => return Err(ion_str!("string::join requires a list as first argument")),
347        };
348        let sep = if args.len() > 1 {
349            args[1].as_str().unwrap_or("").to_string()
350        } else {
351            String::new()
352        };
353        let parts: Vec<String> = items.iter().map(|v| format!("{}", v)).collect();
354        Ok(Value::Str(parts.join(&sep)))
355    });
356
357    m
358}
359
360/// Register all stdlib modules in the given environment.
361pub fn register_stdlib(env: &mut crate::env::Env) {
362    let math = math_module();
363    env.define(math.name.clone(), math.to_value(), false);
364
365    let json = json_module();
366    env.define(json.name.clone(), json.to_value(), false);
367
368    let io = io_module();
369    env.define(io.name.clone(), io.to_value(), false);
370
371    let string_mod = string_module();
372    env.define(string_mod.name.clone(), string_mod.to_value(), false);
373}
ion_core/stdlib.rs

ion_core/
stdlib.rs
