git.delta.rocks / jrsonnet / refs/commits / a9b3ad095ce8

--- a/crates/jsonnet-evaluator/Cargo.toml
+++ b/crates/jsonnet-evaluator/Cargo.toml
@@ -7,8 +7,10 @@
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [features]
-default = ["serialized-stdlib"]
+default = ["serialized-stdlib", "faster"]
 serialized-stdlib = ["serde", "bincode"]
+# Replace some standard library functions with faster implementations
+faster = []
 
 [dependencies]
 jsonnet-parser = { path = "../jsonnet-parser" }

1use bincode::serialize;1use bincode::serialize;
2use jsonnet_parser::{parse, ParserSettings};2use jsonnet_parser::{
3	parse, Expr, FieldMember, FieldName, LocExpr, Member, ObjBody, ParserSettings,
4};
3use jsonnet_stdlib::STDLIB_STR;5use jsonnet_stdlib::STDLIB_STR;
4use std::{6use std::{
5	env,7	env,
6	fs::File,8	fs::File,
7	io::Write,9	io::Write,
8	path::{Path, PathBuf},10	path::{Path, PathBuf},
11	rc::Rc,
9};12};
1013
11fn main() {14fn main() {
18	)21	)
19	.expect("parse");22	.expect("parse");
23
24	let parsed = if cfg!(feature = "faster") {
25		let LocExpr(expr, location) = parsed;
26		LocExpr(
27			Rc::new(match Rc::try_unwrap(expr).unwrap() {
28				Expr::Obj(ObjBody::MemberList(members)) => Expr::Obj(ObjBody::MemberList(
29					members
30						.into_iter()
31						.filter(|p| {
32							!matches!(
33								p,
34								Member::Field(FieldMember {
35									name: FieldName::Fixed(name),
36									..
37								}) if name == "join"
38							)
39						})
40						.collect(),
41				)),
42				_ => panic!("std value should be object"),
43			}),
44			location,
45		)
46	} else {
47		parsed
48	};
2049
21	let out_dir = env::var("OUT_DIR").unwrap();50	let out_dir = env::var("OUT_DIR").unwrap();
22	let dest_path = Path::new(&out_dir).join("stdlib.bincode");51	let dest_path = Path::new(&out_dir).join("stdlib.bincode");

--- a/crates/jsonnet-evaluator/src/evaluate.rs
+++ b/crates/jsonnet-evaluator/src/evaluate.rs
@@ -661,6 +661,76 @@
 							panic!("bad extVar call");
 						}
 					}
+					("std", "filter") => {
+						assert_eq!(args.len(), 2);
+						if let (Val::Func(predicate), Val::Arr(arr)) = (
+							evaluate(context, &args[0].1)?,
+							evaluate(context, &args[1].1)?,
+						) {
+							Val::Arr(
+								arr.into_iter()
+									.filter(|e| {
+										predicate
+											.evaluate_values(&context, &[e.clone()])
+											.unwrap()
+											.try_cast_bool("filter predicate")
+											.unwrap()
+									})
+									.collect(),
+							)
+						} else {
+							panic!("bad filter call");
+						}
+					}
+					// faster
+					("std", "join") => {
+						assert_eq!(args.len(), 2);
+						let joiner = evaluate(context, &args[0].1)?.unwrap_if_lazy()?;
+						let items = evaluate(context, &args[1].1)?.unwrap_if_lazy()?;
+						println!("Before");
+						let result = match (joiner, items) {
+							(Val::Arr(joiner_items), Val::Arr(items)) => {
+								// TODO: Minimal size should be known
+								let mut out = Vec::new();
+
+								let mut first = true;
+								for item in items {
+									if let Val::Arr(items) = item.unwrap_if_lazy()? {
+										if !first {
+											out.extend(joiner_items.iter().cloned());
+										}
+										first = false;
+										out.extend(items);
+									} else {
+										panic!("all array items should be arrays")
+									}
+								}
+
+								Val::Arr(out)
+							}
+							(Val::Str(joiner), Val::Arr(items)) => {
+								let mut out = String::new();
+
+								let mut first = true;
+								for item in items {
+									if let Val::Str(item) = item.unwrap_if_lazy()? {
+										if !first {
+											out += &joiner;
+										}
+										first = false;
+										out += &item;
+									} else {
+										panic!("all array items should be strings")
+									}
+								}
+
+								Val::Str(out)
+							}
+							(joiner, items) => panic!("bad join call: {:?} {:?}", joiner, items),
+						};
+						println!("After");
+						result
+					}
 					(ns, name) => panic!("Intristic not found: {}.{}", ns, name),
 				},
 				Val::Func(f) => {