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

--- a/crates/jrsonnet-evaluator/src/arr/spec.rs
+++ b/crates/jrsonnet-evaluator/src/arr/spec.rs
@@ -9,8 +9,9 @@
 	error::ErrorKind::InfiniteRecursionDetected,
 	evaluate,
 	function::FuncVal,
+	typed::Typed,
 	val::{StrValue, ThunkValue},
-	Context, Error, Result, Thunk, Val,
+	Context, Error, ObjValue, Result, Thunk, Val,
 };
 
 pub trait ArrayLike: Any + Trace + Debug {
@@ -576,3 +577,103 @@
 		self.data.is_cheap()
 	}
 }
+
+#[derive(Trace, Debug)]
+pub struct PickObjectValues {
+	obj: ObjValue,
+	keys: Vec<IStr>,
+}
+
+impl PickObjectValues {
+	pub fn new(obj: ObjValue, keys: Vec<IStr>) -> Self {
+		Self { obj, keys }
+	}
+}
+
+impl ArrayLike for PickObjectValues {
+	fn len(&self) -> usize {
+		self.keys.len()
+	}
+
+	fn get(&self, index: usize) -> Result<Option<Val>> {
+		let Some(key) = self.keys.get(index) else {
+			return Ok(None);
+		};
+		Ok(Some(self.obj.get_or_bail(key.clone())?))
+	}
+
+	fn get_lazy(&self, index: usize) -> Option<Thunk<Val>> {
+		let Some(key) = self.keys.get(index) else {
+			return None;
+		};
+		Some(self.obj.get_lazy_or_bail(key.clone()))
+	}
+
+	fn get_cheap(&self, _index: usize) -> Option<Val> {
+		None
+	}
+
+	fn is_cheap(&self) -> bool {
+		false
+	}
+}
+
+#[derive(Trace, Debug)]
+pub struct PickObjectKeyValues {
+	obj: ObjValue,
+	keys: Vec<IStr>,
+}
+
+impl PickObjectKeyValues {
+	pub fn new(obj: ObjValue, keys: Vec<IStr>) -> Self {
+		Self { obj, keys }
+	}
+}
+
+#[derive(Typed)]
+pub struct KeyValue {
+	key: IStr,
+	value: Thunk<Val>,
+}
+
+impl ArrayLike for PickObjectKeyValues {
+	fn len(&self) -> usize {
+		self.keys.len()
+	}
+
+	fn get(&self, index: usize) -> Result<Option<Val>> {
+		let Some(key) = self.keys.get(index) else {
+			return Ok(None);
+		};
+		Ok(Some(
+			KeyValue::into_untyped(KeyValue {
+				key: key.clone(),
+				value: Thunk::evaluated(self.obj.get_or_bail(key.clone())?),
+			})
+			.expect("convertible"),
+		))
+	}
+
+	fn get_lazy(&self, index: usize) -> Option<Thunk<Val>> {
+		let Some(key) = self.keys.get(index) else {
+			return None;
+		};
+		// Nothing can fail in the key part, yet value is still
+		// lazy-evaluated
+		Some(Thunk::evaluated(
+			KeyValue::into_untyped(KeyValue {
+				key: key.clone(),
+				value: self.obj.get_lazy_or_bail(key.clone()),
+			})
+			.expect("convertible"),
+		))
+	}
+
+	fn get_cheap(&self, _index: usize) -> Option<Val> {
+		None
+	}
+
+	fn is_cheap(&self) -> bool {
+		false
+	}
+}

12use rustc_hash::FxHashMap;12use rustc_hash::FxHashMap;
1313
14use crate::{14use crate::{
15	arr::{PickObjectKeyValues, PickObjectValues},
15	error::{Error, ErrorKind::*},16	error::{suggest_object_fields, Error, ErrorKind::*},
16	function::CallLocation,17	function::CallLocation,
17	gc::{GcHashMap, GcHashSet, TraceBox},18	gc::{GcHashMap, GcHashSet, TraceBox},
18	operator::evaluate_add_op,19	operator::evaluate_add_op,
19	tb, throw,20	tb, throw,
20	val::ThunkValue,21	val::{ArrValue, ThunkValue},
21	MaybeUnbound, Result, State, Thunk, Unbound, Val,22	MaybeUnbound, Result, State, Thunk, Unbound, Val,
22};23};
2324
398		self.0.get_for(key, this)399		self.0.get_for(key, this)
399	}400	}
401
402	pub fn get_or_bail(&self, key: IStr) -> Result<Val> {
403		let Some(value) = self.get(key.clone())? else {
404			let suggestions = suggest_object_fields(self, key.clone());
405			throw!(NoSuchField(key, suggestions))
406		};
407		Ok(value)
408	}
400409
401	fn get_raw(&self, key: IStr, this: ObjValue) -> Result<Option<Val>> {410	fn get_raw(&self, key: IStr, this: ObjValue) -> Result<Option<Val>> {
402		self.0.get_for_uncached(key, this)411		self.0.get_for_uncached(key, this)
452			key,461			key,
453		}))462		}))
454	}463	}
464	pub fn get_lazy_or_bail(&self, key: IStr) -> Thunk<Val> {
465		#[derive(Trace)]
466		struct ThunkGet {
467			obj: ObjValue,
468			key: IStr,
469		}
470		impl ThunkValue for ThunkGet {
471			type Output = Val;
472
473			fn get(self: Box<Self>) -> Result<Self::Output> {
474				Ok(self.obj.get_or_bail(self.key)?)
475			}
476		}
477
478		Thunk::new(ThunkGet {
479			obj: self.clone(),
480			key,
481		})
482	}
455	pub fn ptr_eq(a: &Self, b: &Self) -> bool {483	pub fn ptr_eq(a: &Self, b: &Self) -> bool {
456		Cc::ptr_eq(&a.0, &b.0)484		Cc::ptr_eq(&a.0, &b.0)
457	}485	}
529			preserve_order,557			preserve_order,
530		)558		)
531	}559	}
560	pub fn values_ex(
561		&self,
562		include_hidden: bool,
563		#[cfg(feature = "exp-preserve-order")] preserve_order: bool,
564	) -> ArrValue {
565		ArrValue::new(PickObjectValues::new(
566			self.clone(),
567			self.fields_ex(
568				include_hidden,
569				#[cfg(feature = "exp-preserve-order")]
570				preserve_order,
571			),
572		))
573	}
574	pub fn values(&self, #[cfg(feature = "exp-preserve-order")] preserve_order: bool) -> ArrValue {
575		self.values_ex(
576			false,
577			#[cfg(feature = "exp-preserve-order")]
578			preserve_order,
579		)
580	}
581	pub fn key_values_ex(
582		&self,
583		include_hidden: bool,
584		#[cfg(feature = "exp-preserve-order")] preserve_order: bool,
585	) -> ArrValue {
586		ArrValue::new(PickObjectKeyValues::new(
587			self.clone(),
588			self.fields_ex(
589				include_hidden,
590				#[cfg(feature = "exp-preserve-order")]
591				preserve_order,
592			),
593		))
594	}
595	pub fn key_values(
596		&self,
597		#[cfg(feature = "exp-preserve-order")] preserve_order: bool,
598	) -> ArrValue {
599		self.key_values_ex(
600			false,
601			#[cfg(feature = "exp-preserve-order")]
602			preserve_order,
603		)
604	}
532}605}
533606
534impl OopObject {607impl OopObject {

--- a/crates/jrsonnet-evaluator/src/val.rs
+++ b/crates/jrsonnet-evaluator/src/val.rs
@@ -1,7 +1,6 @@
 use std::{
 	cell::RefCell,
 	fmt::{self, Debug, Display},
-	hash::Hasher,
 	mem::replace,
 	rc::Rc,
 };
@@ -9,7 +8,6 @@
 use jrsonnet_gcmodule::{Cc, Trace};
 use jrsonnet_interner::IStr;
 use jrsonnet_types::ValType;
-use rustc_hash::FxHasher;
 
 pub use crate::arr::{ArrValue, ArrayLike};
 use crate::{
@@ -50,6 +48,12 @@
 	pub fn errored(e: Error) -> Self {
 		Self(Cc::new(RefCell::new(ThunkInner::Errored(e))))
 	}
+	pub fn result(res: Result<T, Error>) -> Self {
+		match res {
+			Ok(o) => Self::evaluated(o),
+			Err(e) => Self::errored(e),
+		}
+	}
 }
 
 impl<T> Thunk<T>

--- a/crates/jrsonnet-stdlib/src/lib.rs
+++ b/crates/jrsonnet-stdlib/src/lib.rs
@@ -138,6 +138,10 @@
 		("base64DecodeBytes", builtin_base64_decode_bytes::INST),
 		// Objects
 		("objectFieldsEx", builtin_object_fields_ex::INST),
+		("objectValues", builtin_object_values::INST),
+		("objectValuesAll", builtin_object_values_all::INST),
+		("objectKeysValues", builtin_object_keys_values::INST),
+		("objectKeysValuesAll", builtin_object_keys_values_all::INST),
 		("objectHasEx", builtin_object_has_ex::INST),
 		("objectRemoveKey", builtin_object_remove_key::INST),
 		// Manifest

--- a/crates/jrsonnet-stdlib/src/objects.rs
+++ b/crates/jrsonnet-stdlib/src/objects.rs
@@ -1,6 +1,6 @@
 use jrsonnet_evaluator::{
 	function::builtin,
-	val::{StrValue, Val},
+	val::{ArrValue, StrValue, Val},
 	IStr, ObjValue, ObjValueBuilder,
 };
 
@@ -23,6 +23,82 @@
 		.collect::<Vec<_>>()
 }
 
+pub fn builtin_object_values_ex(
+	o: ObjValue,
+	include_hidden: bool,
+	#[cfg(feature = "exp-preserve-order")] preserve_order: Option<bool>,
+) -> ArrValue {
+	#[cfg(feature = "exp-preserve-order")]
+	let preserve_order = preserve_order.unwrap_or(false);
+	o.values_ex(
+		include_hidden,
+		#[cfg(feature = "exp-preserve-order")]
+		preserve_order,
+	)
+}
+#[builtin]
+pub fn builtin_object_values(
+	o: ObjValue,
+	#[cfg(feature = "exp-preserve-order")] preserve_order: Option<bool>,
+) -> ArrValue {
+	builtin_object_values_ex(
+		o,
+		false,
+		#[cfg(feature = "exp-preserve-order")]
+		preserve_order,
+	)
+}
+#[builtin]
+pub fn builtin_object_values_all(
+	o: ObjValue,
+	#[cfg(feature = "exp-preserve-order")] preserve_order: Option<bool>,
+) -> ArrValue {
+	builtin_object_values_ex(
+		o,
+		true,
+		#[cfg(feature = "exp-preserve-order")]
+		preserve_order,
+	)
+}
+
+pub fn builtin_object_keys_values_ex(
+	o: ObjValue,
+	include_hidden: bool,
+	#[cfg(feature = "exp-preserve-order")] preserve_order: Option<bool>,
+) -> ArrValue {
+	#[cfg(feature = "exp-preserve-order")]
+	let preserve_order = preserve_order.unwrap_or(false);
+	o.key_values_ex(
+		include_hidden,
+		#[cfg(feature = "exp-preserve-order")]
+		preserve_order,
+	)
+}
+#[builtin]
+pub fn builtin_object_keys_values(
+	o: ObjValue,
+	#[cfg(feature = "exp-preserve-order")] preserve_order: Option<bool>,
+) -> ArrValue {
+	builtin_object_keys_values_ex(
+		o,
+		false,
+		#[cfg(feature = "exp-preserve-order")]
+		preserve_order,
+	)
+}
+#[builtin]
+pub fn builtin_object_keys_values_all(
+	o: ObjValue,
+	#[cfg(feature = "exp-preserve-order")] preserve_order: Option<bool>,
+) -> ArrValue {
+	builtin_object_keys_values_ex(
+		o,
+		true,
+		#[cfg(feature = "exp-preserve-order")]
+		preserve_order,
+	)
+}
+
 #[builtin]
 pub fn builtin_object_has_ex(obj: ObjValue, fname: IStr, hidden: bool) -> bool {
 	obj.has_field_ex(fname, hidden)

--- a/crates/jrsonnet-stdlib/src/std.jsonnet
+++ b/crates/jrsonnet-stdlib/src/std.jsonnet
@@ -268,18 +268,6 @@
   objectHasAll(o, f)::
     std.objectHasEx(o, f, true),
 
-  objectValues(o)::
-    [o[k] for k in std.objectFields(o)],
-
-  objectValuesAll(o)::
-    [o[k] for k in std.objectFieldsAll(o)],
-
-  objectKeysValues(o)::
-    [{ key: k, value: o[k] } for k in std.objectFields(o)],
-	
-  objectKeysValuesAll(o)::
-		[{ key: k, value: o[k] } for k in std.objectFieldsAll(o)],
-
   resolvePath(f, r)::
     local arr = std.split(f, '/');
     std.join('/', std.makeArray(std.length(arr) - 1, function(i) arr[i]) + [r]),