`e88030decfb4`

3 files changed

modifiedcrates/jrsonnet-stdlib/src/lib.rsdiff before after both

106		("format", builtin_format::INST),106		("format", builtin_format::INST),
107		// Sort107		// Sort
108		("sort", builtin_sort::INST),108		("sort", builtin_sort::INST),
109		("uniq", builtin_uniq::INST),
110		("set", builtin_set::INST),
109		// Hash111		// Hash
110		("md5", builtin_md5::INST),112		("md5", builtin_md5::INST),
111		#[cfg(feature = "exp-more-hashes")]113		#[cfg(feature = "exp-more-hashes")]

modifiedcrates/jrsonnet-stdlib/src/sort.rsdiff before after both

1use jrsonnet_evaluator::{1use jrsonnet_evaluator::{
2	error::Result,2	error::Result,
3	function::{builtin, CallLocation, FuncVal},3	function::{builtin, FuncVal},
4	throw,4	throw,
5	val::ArrValue,5	val::{equals, ArrValue},
6	Context, Val,6	Thunk, Val,
7};7};
8use jrsonnet_gcmodule::Cc;
89
9#[derive(Copy, Clone)]10#[derive(Copy, Clone)]
10enum SortKeyType {11enum SortKeyType {
28}29}
2930
30fn get_sort_type<T>(31fn get_sort_type<T>(values: &[T], key_getter: impl Fn(&T) -> &Val) -> Result<SortKeyType> {
31	values: &mut [T],
32	key_getter: impl Fn(&mut T) -> &mut Val,
33) -> Result<SortKeyType> {
34	let mut sort_type = SortKeyType::Unknown;32	let mut sort_type = SortKeyType::Unknown;
35	for i in values.iter_mut() {33	for i in values.iter() {
36		let i = key_getter(i);34		let i = key_getter(i);
37		match (i, sort_type) {35		match (i, sort_type) {
38			(Val::Str(_), SortKeyType::Unknown) => sort_type = SortKeyType::String,36			(Val::Str(_), SortKeyType::Unknown) => sort_type = SortKeyType::String,
47	Ok(sort_type)45	Ok(sort_type)
48}46}
4947
50/// * `key_getter` - None, if identity sort required
51pub fn sort(ctx: Context, mut values: Vec<Val>, key_getter: FuncVal) -> Result<Vec<Val>> {48fn sort_identity(mut values: Vec<Val>) -> Result<Vec<Val>> {
52	if values.len() <= 1 {49	// Fast path, identity key getter
53		return Ok(values);50	let sort_type = get_sort_type(&values, |k| k)?;
54	}51	match sort_type {
55	if key_getter.is_identity() {52		SortKeyType::Number => values.sort_unstable_by_key(|v| match v {
56		// Fast path, identity key getter53			Val::Num(n) => NonNaNf64(*n),
54			_ => unreachable!(),
55		}),
56		SortKeyType::String => values.sort_unstable_by_key(|v| match v {
57			Val::Str(s) => s.clone(),
58			_ => unreachable!(),
59		}),
60		SortKeyType::Unknown => unreachable!(),
61	};
62	Ok(values)
63}
64
57		let sort_type = get_sort_type(&mut values, |k| k)?;65fn sort_keyf(values: ArrValue, keyf: FuncVal) -> Result<Vec<Thunk<Val>>> {
58		match sort_type {
59			SortKeyType::Number => values.sort_unstable_by_key(|v| match v {
60				Val::Num(n) => NonNaNf64(*n),
61				_ => unreachable!(),
62			}),
63			SortKeyType::String => values.sort_unstable_by_key(|v| match v {
64				Val::Str(s) => s.clone(),
65				_ => unreachable!(),
66			}),
67			SortKeyType::Unknown => unreachable!(),
68		};
69		Ok(values)
70	} else {
71		// Slow path, user provided key getter66	// Slow path, user provided key getter
72		let mut vk = Vec::with_capacity(values.len());67	let mut vk = Vec::with_capacity(values.len());
73		for value in values.iter() {68	for value in values.iter_lazy() {
74			vk.push((69		vk.push((
75				value.clone(),70			value.clone(),
76				key_getter.evaluate(71			keyf.evaluate_simple(&(value.clone(),), false)?,
77					ctx.clone(),
78					CallLocation::native(),
79					&(value.clone(),),
80					true,
81				)?,
82			));72		));
83		}73	}
84		let sort_type = get_sort_type(&mut vk, |v| &mut v.1)?;74	let sort_type = get_sort_type(&mut vk, |v| &v.1)?;
85		match sort_type {75	match sort_type {
86			SortKeyType::Number => vk.sort_by_key(|v| match v.1 {76		SortKeyType::Number => vk.sort_by_key(|v| match v.1 {
87				Val::Num(n) => NonNaNf64(n),77			Val::Num(n) => NonNaNf64(n),
95		};85	};
96		Ok(vk.into_iter().map(|v| v.0).collect())86	Ok(vk.into_iter().map(|v| v.0).collect())
97	}87}
98}88
89/// * `key_getter` - None, if identity sort required
90pub fn sort(values: ArrValue, key_getter: FuncVal) -> Result<ArrValue> {
91	if values.len() <= 1 {
92		return Ok(values);
93	}
94	if key_getter.is_identity() {
95		Ok(ArrValue::eager(sort_identity(
96			values.iter().collect::<Result<Vec<Val>>>()?,
97		)?))
98	} else {
99		Ok(ArrValue::lazy(Cc::new(sort_keyf(values, key_getter)?)))
100	}
101}
99102
100#[builtin]103#[builtin]
101#[allow(non_snake_case)]104#[allow(non_snake_case)]
102pub fn builtin_sort(ctx: Context, arr: ArrValue, keyF: Option<FuncVal>) -> Result<ArrValue> {105pub fn builtin_sort(arr: ArrValue, keyF: Option<FuncVal>) -> Result<ArrValue> {
106	if arr.len() <= 1 {
107		return Ok(arr);
108	}
109	Ok(super::sort::sort(
110		arr,
111		keyF.unwrap_or_else(FuncVal::identity),
112	)?)
113}
114
115fn uniq_identity(arr: Vec<Val>) -> Result<Vec<Val>> {
116	let mut out = Vec::new();
117	let mut last = arr[0].clone();
118	out.push(last.clone());
119	for next in arr.into_iter().skip(1) {
120		if !equals(&last, &next)? {
121			out.push(next.clone());
122		}
123		last = next;
124	}
125	Ok(out)
126}
127
128fn uniq_keyf(arr: ArrValue, keyf: FuncVal) -> Result<Vec<Thunk<Val>>> {
129	let mut out = Vec::new();
130	let last_value = arr.get_lazy(0).unwrap();
131	let mut last_key = keyf.evaluate_simple(&(last_value.clone(),), false)?;
132	out.push(last_value.clone());
133
134	for next in arr.iter_lazy().skip(1) {
135		let next_key = keyf.evaluate_simple(&(next.clone(),), false)?;
136		if !equals(&last_key, &next_key)? {
137			out.push(next.clone());
138		}
139		last_key = next_key;
140	}
141	Ok(out)
142}
143
144#[builtin]
145#[allow(non_snake_case)]
146pub fn builtin_uniq(arr: ArrValue, keyF: Option<FuncVal>) -> Result<ArrValue> {
103	if arr.len() <= 1 {147	if arr.len() <= 1 {
104		return Ok(arr);148		return Ok(arr);
105	}149	}
150	let keyF = keyF.unwrap_or(FuncVal::identity());
151	if keyF.is_identity() {
106	Ok(ArrValue::eager(super::sort::sort(152		Ok(ArrValue::eager(uniq_identity(
107		ctx,
108		arr.iter().collect::<Result<Vec<_>>>()?,153			arr.iter().collect::<Result<Vec<Val>>>()?,
109		keyF.unwrap_or_else(FuncVal::identity),
110	)?))154		)?))
155	} else {
156		Ok(ArrValue::lazy(Cc::new(uniq_keyf(arr, keyF)?)))
157	}
111}158}
159
160#[builtin]
161#[allow(non_snake_case)]
162pub fn builtin_set(arr: ArrValue, keyF: Option<FuncVal>) -> Result<ArrValue> {
163	let keyF = keyF.unwrap_or(FuncVal::identity());
164	if keyF.is_identity() {
165		let arr = arr.iter().collect::<Result<Vec<Val>>>()?;
166		let arr = sort_identity(arr)?;
167		let arr = uniq_identity(arr)?;
168		Ok(ArrValue::eager(arr))
169	} else {
170		let arr = sort_keyf(arr, keyF.clone())?;
171		let arr = uniq_keyf(ArrValue::lazy(Cc::new(arr)), keyF)?;
172		Ok(ArrValue::lazy(Cc::new(arr)))
173	}
174}
112175

modifiedcrates/jrsonnet-stdlib/src/std.jsonnetdiff before after both

196196
197      aux(value),197      aux(value),
198198
199  uniq(arr, keyF=id)::
200    local f(a, b) =
201      if std.length(a) == 0 then
202        [b]
203      else if keyF(a[std.length(a) - 1]) == keyF(b) then
204        a
205      else
206        a + [b];
207    std.foldl(f, arr, []),
208
209  set(arr, keyF=id)::
210    std.uniq(std.sort(arr, keyF), keyF),
211
212  setUnion(a, b, keyF=id)::199  setUnion(a, b, keyF=id)::
213    // NOTE: order matters, values in `a` win200    // NOTE: order matters, values in `a` win
214    local aux(a, b, i, j, acc) =201    local aux(a, b, i, j, acc) =