git.delta.rocks / jrsonnet / refs/commits / 6f6b79fd0e0d

--- a/bindings/jsonnet/src/val_make.rs
+++ b/bindings/jsonnet/src/val_make.rs
@@ -50,7 +50,7 @@
 /// Assign elements with [`jsonnet_json_array_append`].
 #[no_mangle]
 pub extern "C" fn jsonnet_json_make_array(_vm: &VM) -> *mut Val {
-	Box::into_raw(Box::new(Val::Arr(ArrValue::eager(Vec::new()))))
+	Box::into_raw(Box::new(Val::arr(())))
 }
 
 /// Make a `JsonnetJsonValue` representing an object.

--- a/bindings/jsonnet/src/val_modify.rs
+++ b/bindings/jsonnet/src/val_modify.rs
@@ -24,7 +24,7 @@
 			}
 
 			new.push(Thunk::evaluated(val.clone()));
-			*arr = Val::Arr(ArrValue::lazy(new));
+			*arr = Val::arr(new);
 		}
 		_ => panic!("should receive array"),
 	}

--- a/crates/jrsonnet-evaluator/src/arr/mod.rs
+++ b/crates/jrsonnet-evaluator/src/arr/mod.rs
@@ -6,7 +6,6 @@
 };
 
 use jrsonnet_gcmodule::{Cc, cc_dyn};
-use jrsonnet_interner::IBytes;
 use jrsonnet_ir::Expr;
 
 use crate::{Context, Result, Thunk, Val, function::NativeFn, typed::IntoUntyped};
@@ -35,28 +34,17 @@
 
 impl ArrValue {
 	pub fn empty() -> Self {
-		Self::new(RangeArray::empty())
+		Self::new(())
 	}
 
 	pub fn expr(ctx: Context, exprs: Rc<Vec<Expr>>) -> Self {
 		Self::new(ExprArray::new(ctx, exprs))
-	}
-
-	pub fn lazy(thunks: Vec<Thunk<Val>>) -> Self {
-		Self::new(LazyArray(thunks))
 	}
 
-	pub fn eager(values: Vec<Val>) -> Self {
-		Self::new(EagerArray(values))
-	}
-
 	pub fn repeated(data: Self, repeats: usize) -> Option<Self> {
 		Some(Self::new(RepeatedArray::new(data, repeats)?))
 	}
 
-	pub fn bytes(bytes: IBytes) -> Self {
-		Self::new(BytesArray(bytes))
-	}
 	pub fn chars(chars: impl Iterator<Item = char>) -> Self {
 		Self::new(CharArray(chars.collect()))
 	}
@@ -83,7 +71,7 @@
 					out.push(i);
 				}
 			}
-			return Ok(Self::eager(out));
+			return Ok(Self::new(out));
 		};
 
 		let mut out = Vec::new();
@@ -92,29 +80,16 @@
 				out.push(i);
 			}
 		}
-		Ok(Self::lazy(out))
+		Ok(Self::new(out))
 	}
 
 	pub fn extended(a: Self, b: Self) -> Self {
-		// TODO: benchmark for an optimal value, currently just a arbitrary choice
-		const ARR_EXTEND_THRESHOLD: usize = 1000;
-
 		if a.is_empty() {
 			b
 		} else if b.is_empty() {
 			a
-		} else if a.len() + b.len() > ARR_EXTEND_THRESHOLD {
+		} else {
 			Self::new(ExtendedArray::new(a, b))
-		} else if let (Some(a), Some(b)) = (a.iter_cheap(), b.iter_cheap()) {
-			let mut out = Vec::with_capacity(a.len() + b.len());
-			out.extend(a);
-			out.extend(b);
-			Self::eager(out)
-		} else {
-			let mut out = Vec::with_capacity(a.len() + b.len());
-			out.extend(a.iter_lazy());
-			out.extend(b.iter_lazy());
-			Self::lazy(out)
 		}
 	}
 
@@ -165,19 +140,15 @@
 		self.0.is_empty()
 	}
 
+	pub fn is_cheap(&self) -> bool {
+		self.0.is_cheap()
+	}
+
 	/// Get array element by index, evaluating it, if it is lazy.
 	///
 	/// Returns `None` on out-of-bounds condition.
 	pub fn get(&self, index: usize) -> Result<Option<Val>> {
 		self.0.get(index)
-	}
-
-	/// Returns None if get is either non cheap, or out of bounds
-	/// Note that non-cheap access includes errorable values
-	///
-	/// Prefer it to `get_lazy`, but use `get` when you can.
-	fn get_cheap(&self, index: usize) -> Option<Val> {
-		self.0.get_cheap(index)
 	}
 
 	/// Get array element by index, without evaluation.
@@ -196,15 +167,6 @@
 		(0..self.len()).map(|i| self.get_lazy(i).expect("length checked"))
 	}
 
-	/// Prefer it over `iter_lazy`, but do not use it where `iter` will do.
-	pub fn iter_cheap(&self) -> Option<impl ArrayLikeIter<Val> + '_> {
-		if self.is_cheap() {
-			Some((0..self.len()).map(|i| self.get_cheap(i).expect("length and is_cheap checked")))
-		} else {
-			None
-		}
-	}
-
 	/// Return a reversed view on current array.
 	#[must_use]
 	pub fn reversed(self) -> Self {
@@ -213,50 +175,25 @@
 
 	pub fn ptr_eq(a: &Self, b: &Self) -> bool {
 		Cc::ptr_eq(&a.0, &b.0)
-	}
-
-	/// Is this vec supports `.get_cheap()?`
-	pub fn is_cheap(&self) -> bool {
-		self.0.is_cheap()
 	}
 
 	pub fn as_any(&self) -> &dyn Any {
 		&self.0
 	}
 }
-impl From<Vec<Val>> for ArrValue {
-	fn from(value: Vec<Val>) -> Self {
-		Self::eager(value)
-	}
-}
-impl From<Vec<Thunk<Val>>> for ArrValue {
-	fn from(value: Vec<Thunk<Val>>) -> Self {
-		Self::lazy(value)
-	}
-}
-impl FromIterator<Val> for ArrValue {
-	fn from_iter<T: IntoIterator<Item = Val>>(iter: T) -> Self {
-		Self::eager(iter.into_iter().collect())
+impl<T> From<T> for ArrValue
+where
+	T: ArrayLike,
+{
+	fn from(value: T) -> Self {
+		Self::new(value)
 	}
 }
-impl ArrayLike for ArrValue {
-	fn len(&self) -> usize {
-		self.0.len()
-	}
-
-	fn get(&self, index: usize) -> Result<Option<Val>> {
-		self.0.get(index)
-	}
-
-	fn get_lazy(&self, index: usize) -> Option<Thunk<Val>> {
-		self.0.get_lazy(index)
-	}
-
-	fn get_cheap(&self, index: usize) -> Option<Val> {
-		self.0.get_cheap(index)
-	}
-
-	fn is_cheap(&self) -> bool {
-		self.0.is_cheap()
+impl<I> FromIterator<I> for ArrValue
+where
+	Vec<I>: ArrayLike,
+{
+	fn from_iter<T: IntoIterator<Item = I>>(iter: T) -> Self {
+		Self::new(iter.into_iter().collect::<Vec<_>>())
 	}
 }

--- a/crates/jrsonnet-evaluator/src/arr/spec.rs
+++ b/crates/jrsonnet-evaluator/src/arr/spec.rs
@@ -1,4 +1,10 @@
-use std::{any::Any, cell::RefCell, fmt::Debug, mem::replace, rc::Rc};
+use std::{
+	any::Any,
+	cell::RefCell,
+	fmt::{self, Debug},
+	mem::replace,
+	rc::Rc,
+};
 
 use jrsonnet_gcmodule::{Cc, Trace};
 use jrsonnet_interner::{IBytes, IStr};
@@ -21,11 +27,45 @@
 	}
 	fn get(&self, index: usize) -> Result<Option<Val>>;
 	fn get_lazy(&self, index: usize) -> Option<Thunk<Val>>;
-	fn get_cheap(&self, index: usize) -> Option<Val>;
 
-	fn is_cheap(&self) -> bool;
+	fn is_cheap(&self) -> bool {
+		false
+	}
+}
+trait ArrayCheap {
+	fn get(&self, index: usize) -> Option<Val>;
+	fn len(&self) -> usize;
 }
+impl<T> ArrayLike for T
+where
+	T: Any + Trace + Debug + ArrayCheap,
+{
+	fn len(&self) -> usize {
+		<T as ArrayCheap>::len(self)
+	}
+
+	fn get(&self, index: usize) -> Result<Option<Val>> {
+		Ok(<T as ArrayCheap>::get(self, index))
+	}
 
+	fn get_lazy(&self, index: usize) -> Option<Thunk<Val>> {
+		<T as ArrayCheap>::get(self, index).map(Thunk::evaluated)
+	}
+
+	fn is_cheap(&self) -> bool {
+		true
+	}
+}
+
+impl ArrayCheap for () {
+	fn len(&self) -> usize {
+		0
+	}
+	fn get(&self, _index: usize) -> Option<Val> {
+		None
+	}
+}
+
 #[derive(Debug, Trace)]
 pub struct SliceArray {
 	pub(crate) inner: ArrValue,
@@ -52,9 +92,6 @@
 		self.inner.get_lazy(self.map_idx(index))
 	}
 
-	fn get_cheap(&self, index: usize) -> Option<Val> {
-		self.inner.get_cheap(self.map_idx(index))
-	}
 	fn is_cheap(&self) -> bool {
 		self.inner.is_cheap()
 	}
@@ -62,47 +99,21 @@
 
 #[derive(Trace, Debug)]
 pub struct CharArray(pub Vec<char>);
-impl ArrayLike for CharArray {
+impl ArrayCheap for CharArray {
 	fn len(&self) -> usize {
-		self.0.len()
+		self.0.as_slice().len()
 	}
-
-	fn get(&self, index: usize) -> Result<Option<Val>> {
-		Ok(self.get_cheap(index))
-	}
-
-	fn get_lazy(&self, index: usize) -> Option<Thunk<Val>> {
-		self.get_cheap(index).map(Thunk::evaluated)
-	}
-
-	fn get_cheap(&self, index: usize) -> Option<Val> {
-		self.0.get(index).map(|v| Val::string(*v))
-	}
-	fn is_cheap(&self) -> bool {
-		true
+	fn get(&self, index: usize) -> Option<Val> {
+		self.0.as_slice().get(index).map(|v| Val::string(*v))
 	}
 }
 
-#[derive(Trace, Debug)]
-pub struct BytesArray(pub IBytes);
-impl ArrayLike for BytesArray {
+impl ArrayCheap for IBytes {
 	fn len(&self) -> usize {
-		self.0.len()
-	}
-
-	fn get(&self, index: usize) -> Result<Option<Val>> {
-		Ok(self.get_cheap(index))
-	}
-
-	fn get_lazy(&self, index: usize) -> Option<Thunk<Val>> {
-		self.get_cheap(index).map(Thunk::evaluated)
-	}
-
-	fn get_cheap(&self, index: usize) -> Option<Val> {
-		self.0.get(index).map(|v| Val::Num((*v).into()))
+		self.as_slice().len()
 	}
-	fn is_cheap(&self) -> bool {
-		true
+	fn get(&self, index: usize) -> Option<Val> {
+		self.as_slice().get(index).map(|v| Val::Num((*v).into()))
 	}
 }
 
@@ -190,9 +201,6 @@
 			expr: self.clone(),
 			index,
 		}))
-	}
-	fn get_cheap(&self, _index: usize) -> Option<Val> {
-		None
 	}
 	fn is_cheap(&self) -> bool {
 		false
@@ -275,61 +283,34 @@
 		self.len
 	}
 
-	fn get_cheap(&self, index: usize) -> Option<Val> {
-		if self.split > index {
-			self.a.get_cheap(index)
-		} else {
-			self.b.get_cheap(index - self.split)
-		}
-	}
 	fn is_cheap(&self) -> bool {
 		self.a.is_cheap() && self.b.is_cheap()
 	}
 }
 
-#[derive(Trace, Debug)]
-pub struct LazyArray(pub Vec<Thunk<Val>>);
-impl ArrayLike for LazyArray {
+impl<T> ArrayLike for Vec<T>
+where
+	T: IntoUntyped + Trace + fmt::Debug,
+	for<'a> &'a T: IntoUntyped,
+{
 	fn len(&self) -> usize {
-		self.0.len()
+		self.as_slice().len()
 	}
+
 	fn get(&self, index: usize) -> Result<Option<Val>> {
-		let Some(v) = self.0.get(index) else {
+		let Some(elem) = self.as_slice().get(index) else {
 			return Ok(None);
 		};
-		v.evaluate().map(Some)
-	}
-	fn get_cheap(&self, _index: usize) -> Option<Val> {
-		None
-	}
-	fn get_lazy(&self, index: usize) -> Option<Thunk<Val>> {
-		self.0.get(index).cloned()
-	}
-	fn is_cheap(&self) -> bool {
-		false
-	}
-}
-
-#[derive(Trace, Debug)]
-pub struct EagerArray(pub Vec<Val>);
-impl ArrayLike for EagerArray {
-	fn len(&self) -> usize {
-		self.0.len()
+		IntoUntyped::into_untyped(elem).map(Some)
 	}
 
-	fn get(&self, index: usize) -> Result<Option<Val>> {
-		Ok(self.0.get(index).cloned())
-	}
-
 	fn get_lazy(&self, index: usize) -> Option<Thunk<Val>> {
-		self.0.get(index).cloned().map(Thunk::evaluated)
+		let elem = self.as_slice().get(index)?;
+		Some(IntoUntyped::into_lazy_untyped(elem))
 	}
 
-	fn get_cheap(&self, index: usize) -> Option<Val> {
-		self.0.get(index).cloned()
-	}
 	fn is_cheap(&self) -> bool {
-		true
+		!T::provides_lazy()
 	}
 }
 
@@ -363,28 +344,12 @@
 		WithExactSize(self.start..=self.end, self.size())
 	}
 }
-
-impl ArrayLike for RangeArray {
-	fn len(&self) -> usize {
-		self.size()
-	}
-	fn is_empty(&self) -> bool {
-		self.size() == 0
-	}
-
-	fn get(&self, index: usize) -> Result<Option<Val>> {
-		Ok(self.get_cheap(index))
-	}
-
-	fn get_lazy(&self, index: usize) -> Option<Thunk<Val>> {
-		self.get_cheap(index).map(Thunk::evaluated)
-	}
-
-	fn get_cheap(&self, index: usize) -> Option<Val> {
+impl ArrayCheap for RangeArray {
+	fn get(&self, index: usize) -> Option<Val> {
 		self.range().nth(index).map(|i| Val::Num(i.into()))
 	}
-	fn is_cheap(&self) -> bool {
-		true
+	fn len(&self) -> usize {
+		self.size()
 	}
 }
 
@@ -403,9 +368,6 @@
 		self.0.get_lazy(self.0.len() - index - 1)
 	}
 
-	fn get_cheap(&self, index: usize) -> Option<Val> {
-		self.0.get_cheap(self.0.len() - index - 1)
-	}
 	fn is_cheap(&self) -> bool {
 		self.0.is_cheap()
 	}
@@ -509,13 +471,6 @@
 			arr: self.clone(),
 			index,
 		}))
-	}
-
-	fn get_cheap(&self, _index: usize) -> Option<Val> {
-		None
-	}
-	fn is_cheap(&self) -> bool {
-		false
 	}
 }
 
@@ -534,6 +489,12 @@
 			total_len,
 		})
 	}
+	fn map_idx(&self, index: usize) -> Option<usize> {
+		if index > self.total_len {
+			return None;
+		}
+		Some(index % self.data.len())
+	}
 }
 
 impl ArrayLike for RepeatedArray {
@@ -542,25 +503,17 @@
 	}
 
 	fn get(&self, index: usize) -> Result<Option<Val>> {
-		if index > self.total_len {
+		let Some(idx) = self.map_idx(index) else {
 			return Ok(None);
-		}
-		self.data.get(index % self.data.len())
+		};
+		self.data.get(idx)
 	}
 
 	fn get_lazy(&self, index: usize) -> Option<Thunk<Val>> {
-		if index > self.total_len {
-			return None;
-		}
-		self.data.get_lazy(index % self.data.len())
+		let idx = self.map_idx(index)?;
+		self.data.get_lazy(idx)
 	}
 
-	fn get_cheap(&self, index: usize) -> Option<Val> {
-		if index > self.total_len {
-			return None;
-		}
-		self.data.get_cheap(index % self.data.len())
-	}
 	fn is_cheap(&self) -> bool {
 		self.data.is_cheap()
 	}
@@ -584,21 +537,17 @@
 	}
 
 	fn get(&self, index: usize) -> Result<Option<Val>> {
-		let Some(key) = self.keys.get(index) else {
+		let Some(key) = self.keys.as_slice().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 key = self.keys.get(index)?;
+		let key = self.keys.as_slice().get(index)?;
 		Some(self.obj.get_lazy_or_bail(key.clone()))
 	}
 
-	fn get_cheap(&self, _index: usize) -> Option<Val> {
-		None
-	}
-
 	fn is_cheap(&self) -> bool {
 		false
 	}
@@ -628,7 +577,7 @@
 	}
 
 	fn get(&self, index: usize) -> Result<Option<Val>> {
-		let Some(key) = self.keys.get(index) else {
+		let Some(key) = self.keys.as_slice().get(index) else {
 			return Ok(None);
 		};
 		Ok(Some(
@@ -641,7 +590,7 @@
 	}
 
 	fn get_lazy(&self, index: usize) -> Option<Thunk<Val>> {
-		let key = self.keys.get(index)?;
+		let key = self.keys.as_slice().get(index)?;
 		// Nothing can fail in the key part, yet value is still
 		// lazy-evaluated
 		Some(Thunk::evaluated(
@@ -651,10 +600,6 @@
 			})
 			.expect("convertible"),
 		))
-	}
-
-	fn get_cheap(&self, _index: usize) -> Option<Val> {
-		None
 	}
 
 	fn is_cheap(&self) -> bool {

--- a/crates/jrsonnet-evaluator/src/evaluate/mod.rs
+++ b/crates/jrsonnet-evaluator/src/evaluate/mod.rs
@@ -70,12 +70,12 @@
 			if n.iter().any(|e| !is_trivial(e)) {
 				return None;
 			}
-			Val::Arr(ArrValue::eager(
+			Val::Arr(
 				n.iter()
 					.map(evaluate_trivial)
 					.map(|e| e.expect("checked trivial"))
 					.collect(),
-			))
+			)
 		}
 		_ => return None,
 	})
@@ -145,12 +145,12 @@
 						let fctx = Pending::new();
 						let mut new_bindings = FxHashMap::with_capacity(into.binds_len());
 						let obj = obj.clone();
-						let value = Thunk::evaluated(Val::Arr(ArrValue::lazy(vec![
+						let value = Thunk::evaluated(Val::arr(vec![
 							Thunk::evaluated(Val::string(field.clone())),
-							Thunk!(move || obj.get(field).transpose().expect(
+							obj.get_lazy(field).transpose().expect(
 								"field exists, as field name was obtained from object.fields()",
-							)),
-						])));
+							),
+						]));
 						destruct(into, value, fctx.clone(), &mut new_bindings)?;
 						let ctx = ctx.clone().extend_bindings(new_bindings).into_future(fctx);
 
@@ -528,7 +528,7 @@
 						#[cfg(feature = "exp-null-coaelse")]
 						None if part.null_coaelse => return Ok(Val::Null),
 						None => {
-							let suggestions = suggest_object_fields(&v, key.clone().into_flat());
+							let suggestions = suggest_object_fields(&v, key.into_flat());
 
 							return Err(Error::from(NoSuchField(
 								key.clone().into_flat(),
@@ -628,7 +628,7 @@
 		}
 		Arr(items) => {
 			if items.is_empty() {
-				Val::Arr(ArrValue::empty())
+				Val::arr(())
 			} else {
 				Val::Arr(ArrValue::expr(ctx, items.clone()))
 			}
@@ -640,7 +640,7 @@
 				out.push(Thunk!(move || evaluate(ctx, &expr)));
 				Ok(())
 			})?;
-			Val::Arr(ArrValue::lazy(out))
+			Val::arr(out)
 		}
 		Obj(body) => Val::Obj(evaluate_object(None, ctx, body)?),
 		ObjExtend(a, b) => {
@@ -718,9 +718,7 @@
 						|| s.import_resolved(resolved_path),
 					)?,
 					ImportKind::Str => Val::string(s.import_resolved_str(resolved_path)?),
-					ImportKind::Bin => {
-						Val::Arr(ArrValue::bytes(s.import_resolved_bin(resolved_path)?))
-					}
+					ImportKind::Bin => Val::arr(s.import_resolved_bin(resolved_path)?),
 				}) as Result<Val>
 			})?
 		}

--- a/crates/jrsonnet-evaluator/src/typed/conversions.rs
+++ b/crates/jrsonnet-evaluator/src/typed/conversions.rs
@@ -6,7 +6,7 @@
 
 use crate::{
 	ObjValue, ObjValueBuilder, Result, ResultExt, Thunk, Val,
-	arr::{ArrValue, BytesArray},
+	arr::ArrValue,
 	bail,
 	function::FuncVal,
 	typed::CheckType,
@@ -83,6 +83,12 @@
 pub trait Typed: Sized {
 	const TYPE: &'static ComplexValType;
 }
+impl<T> Typed for &T
+where
+	T: Typed,
+{
+	const TYPE: &'static ComplexValType = <&T as Typed>::TYPE;
+}
 pub trait IntoUntyped: Typed {
 	// Whatever caller should use `into_lazy_untyped` instead of `into_untyped`
 	fn provides_lazy() -> bool {
@@ -93,6 +99,7 @@
 		Thunk::from(Self::into_untyped(typed))
 	}
 }
+
 pub trait IntoUntypedResult: Typed {
 	/// Hack to make builtins be able to return non-result values, and make macros able to convert those values to result
 	/// This method returns identity in impl Typed for Result, and should not be overriden
@@ -157,6 +164,26 @@
 		inner.map(<ThunkIntoUntyped<T>>::default())
 	}
 }
+impl<T> IntoUntyped for &Thunk<T>
+where
+	T: IntoUntyped + Trace + Clone,
+{
+	fn into_untyped(typed: Self) -> Result<Val> {
+		T::into_untyped(typed.evaluate()?)
+	}
+	fn provides_lazy() -> bool {
+		true
+	}
+
+	fn into_lazy_untyped(inner: Self) -> Thunk<Val> {
+		// Avoid lazy mapping
+		let inner = match try_cast_thunk_val(inner.clone()) {
+			Ok(v) => return v,
+			Err(e) => e,
+		};
+		inner.map(<ThunkIntoUntyped<T>>::default())
+	}
+}
 
 fn try_cast_thunk_t<T: 'static>(typed: Thunk<Val>) -> Result<Thunk<T>, Thunk<Val>> {
 	if TypeId::of::<T>() == TypeId::of::<Val>() {
@@ -221,6 +248,11 @@
 				}
 			}
 		}
+		impl IntoUntyped for &$ty {
+			fn into_untyped(value: Self) -> Result<Val> {
+				Ok(Val::Num((*value).into()))
+			}
+		}
 		impl IntoUntyped for $ty {
 			fn into_untyped(value: Self) -> Result<Val> {
 				Ok(Val::Num(value.into()))
@@ -305,6 +337,11 @@
 impl Typed for f64 {
 	const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Num);
 }
+impl IntoUntyped for &f64 {
+	fn into_untyped(value: Self) -> Result<Val> {
+		Ok(Val::try_num(*value)?)
+	}
+}
 impl IntoUntyped for f64 {
 	fn into_untyped(value: Self) -> Result<Val> {
 		Ok(Val::try_num(value)?)
@@ -324,7 +361,7 @@
 impl Typed for PositiveF64 {
 	const TYPE: &'static ComplexValType = &ComplexValType::BoundedNumber(Some(0.0), None);
 }
-impl IntoUntyped for PositiveF64 {
+impl IntoUntyped for &PositiveF64 {
 	fn into_untyped(value: Self) -> Result<Val> {
 		Ok(Val::try_num(value.0)?)
 	}
@@ -538,6 +575,11 @@
 impl Typed for Val {
 	const TYPE: &'static ComplexValType = &ComplexValType::Any;
 }
+impl IntoUntyped for &Val {
+	fn into_untyped(typed: Self) -> Result<Val> {
+		Ok(typed.clone())
+	}
+}
 impl IntoUntyped for Val {
 	fn into_untyped(typed: Self) -> Result<Val> {
 		Ok(typed)
@@ -567,9 +609,14 @@
 	const TYPE: &'static ComplexValType =
 		&ComplexValType::ArrayRef(&ComplexValType::BoundedNumber(Some(0.0), Some(255.0)));
 }
+impl IntoUntyped for &IBytes {
+	fn into_untyped(value: Self) -> Result<Val> {
+		Ok(Val::arr(value.clone()))
+	}
+}
 impl IntoUntyped for IBytes {
 	fn into_untyped(value: Self) -> Result<Val> {
-		Ok(Val::Arr(ArrValue::bytes(value)))
+		Ok(Val::arr(value))
 	}
 }
 impl FromUntyped for IBytes {
@@ -578,8 +625,8 @@
 			<Self as Typed>::TYPE.check(&value)?;
 			unreachable!()
 		};
-		if let Some(bytes) = a.as_any().downcast_ref::<BytesArray>() {
-			return Ok(bytes.0.as_slice().into());
+		if let Some(bytes) = a.as_any().downcast_ref::<IBytes>() {
+			return Ok(bytes.clone());
 		}
 		<Self as Typed>::TYPE.check(&value)?;
 		// Any::downcast_ref::<ByteArray>(&a);
@@ -596,7 +643,7 @@
 impl Typed for M1 {
 	const TYPE: &'static ComplexValType = &ComplexValType::BoundedNumber(Some(-1.0), Some(-1.0));
 }
-impl IntoUntyped for M1 {
+impl IntoUntyped for &M1 {
 	fn into_untyped(_: Self) -> Result<Val> {
 		Ok(Val::Num(NumValue::new(-1.0).expect("finite")))
 	}
@@ -728,6 +775,11 @@
 impl Typed for bool {
 	const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Bool);
 }
+impl IntoUntyped for &bool {
+	fn into_untyped(value: Self) -> Result<Val> {
+		Ok(Val::Bool(*value))
+	}
+}
 impl IntoUntyped for bool {
 	fn into_untyped(value: Self) -> Result<Val> {
 		Ok(Val::Bool(value))
@@ -764,19 +816,23 @@
 	}
 }
 
-pub struct Null;
-impl Typed for Null {
+impl Typed for () {
 	const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Null);
 }
-impl IntoUntyped for Null {
-	fn into_untyped(_: Self) -> Result<Val> {
+impl IntoUntyped for &() {
+	fn into_untyped((): Self) -> Result<Val> {
 		Ok(Val::Null)
 	}
 }
-impl FromUntyped for Null {
+impl IntoUntyped for () {
+	fn into_untyped((): Self) -> Result<Val> {
+		Ok(Val::Null)
+	}
+}
+impl FromUntyped for () {
 	fn from_untyped(value: Val) -> Result<Self> {
 		<Self as Typed>::TYPE.check(&value)?;
-		Ok(Self)
+		Ok(())
 	}
 }
 
@@ -811,9 +867,9 @@
 impl Typed for NumValue {
 	const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Num);
 }
-impl IntoUntyped for NumValue {
+impl IntoUntyped for &NumValue {
 	fn into_untyped(typed: Self) -> Result<Val> {
-		Ok(Val::Num(typed))
+		Ok(Val::Num(*typed))
 	}
 }
 impl FromUntyped for NumValue {

--- a/crates/jrsonnet-evaluator/src/val.rs
+++ b/crates/jrsonnet-evaluator/src/val.rs
@@ -137,7 +137,7 @@
 
 impl<T> Thunk<T>
 where
-	T: Clone + Trace,
+	T: Trace,
 {
 	pub fn force(&self) -> Result<()> {
 		self.evaluate()?;
@@ -161,7 +161,7 @@
 }
 impl<Input> Thunk<Input>
 where
-	Input: Trace + Clone,
+	Input: Trace,
 {
 	pub fn map<M>(self, mapper: M) -> Thunk<M::Output>
 	where
@@ -355,7 +355,7 @@
 			Self::Tree(Rc::new((a, b, len)))
 		}
 	}
-	pub fn into_flat(self) -> IStr {
+	pub fn into_flat(&self) -> IStr {
 		#[cold]
 		fn write_buf(s: &StrValue, out: &mut String) {
 			match s {
@@ -367,10 +367,10 @@
 			}
 		}
 		match self {
-			Self::Flat(f) => f,
+			Self::Flat(f) => f.clone(),
 			Self::Tree(_) => {
 				let mut buf = String::with_capacity(self.len());
-				write_buf(&self, &mut buf);
+				write_buf(self, &mut buf);
 				buf.into()
 			}
 		}
@@ -701,6 +701,9 @@
 	{
 		Ok(Self::Num(num.try_into()?))
 	}
+	pub fn arr(a: impl ArrayLike) -> Self {
+		Self::Arr(ArrValue::new(a))
+	}
 }
 
 impl From<IStr> for Val {

--- a/crates/jrsonnet-stdlib/src/arrays.rs
+++ b/crates/jrsonnet-stdlib/src/arrays.rs
@@ -34,7 +34,7 @@
 			for _ in 0..*sz {
 				out.push(trivial.clone());
 			}
-			Ok(ArrValue::eager(out))
+			Ok(ArrValue::new(out))
 		},
 	)
 }
@@ -256,7 +256,7 @@
 pub fn builtin_lines(arr: ArrValue) -> Result<IndexableVal> {
 	builtin_join(
 		IndexableVal::Str("\n".into()),
-		ArrValue::extended(arr, ArrValue::eager(vec![Val::string("")])),
+		ArrValue::extended(arr, ArrValue::new(vec![Val::string("")])),
 	)
 }
 
@@ -468,7 +468,7 @@
 					out.push(ele);
 				}
 			}
-			Val::Arr(ArrValue::eager(out))
+			Val::arr(out)
 		}
 		Val::Obj(o) => {
 			let mut out = ObjValueBuilder::new();

--- a/crates/jrsonnet-stdlib/src/sets.rs
+++ b/crates/jrsonnet-stdlib/src/sets.rs
@@ -29,7 +29,11 @@
 
 #[builtin]
 #[allow(non_snake_case, clippy::redundant_closure)]
-pub fn builtin_set_inter(a: ArrValue, b: ArrValue, #[default] keyF: KeyF) -> Result<ArrValue> {
+pub fn builtin_set_inter(
+	a: ArrValue,
+	b: ArrValue,
+	#[default] keyF: KeyF,
+) -> Result<Vec<Thunk<Val>>> {
 	let mut a = a.iter_lazy();
 	let mut b = b.iter_lazy();
 
@@ -60,12 +64,16 @@
 			}
 		}
 	}
-	Ok(ArrValue::lazy(out))
+	Ok(out)
 }
 
 #[builtin]
 #[allow(non_snake_case, clippy::redundant_closure)]
-pub fn builtin_set_diff(a: ArrValue, b: ArrValue, #[default] keyF: KeyF) -> Result<ArrValue> {
+pub fn builtin_set_diff(
+	a: ArrValue,
+	b: ArrValue,
+	#[default] keyF: KeyF,
+) -> Result<Vec<Thunk<Val>>> {
 	let mut a = a.iter_lazy();
 	let mut b = b.iter_lazy();
 
@@ -103,12 +111,16 @@
 		av = a.next();
 		ak = av.clone().map(keyF).transpose()?;
 	}
-	Ok(ArrValue::lazy(out))
+	Ok(out)
 }
 
 #[builtin]
 #[allow(non_snake_case, clippy::redundant_closure)]
-pub fn builtin_set_union(a: ArrValue, b: ArrValue, #[default] keyF: KeyF) -> Result<ArrValue> {
+pub fn builtin_set_union(
+	a: ArrValue,
+	b: ArrValue,
+	#[default] keyF: KeyF,
+) -> Result<Vec<Thunk<Val>>> {
 	let mut a = a.iter_lazy();
 	let mut b = b.iter_lazy();
 
@@ -154,5 +166,5 @@
 		bv = b.next();
 		bk = bv.clone().map(keyF).transpose()?;
 	}
-	Ok(ArrValue::lazy(out))
+	Ok(out)
 }

--- a/crates/jrsonnet-stdlib/src/sort.rs
+++ b/crates/jrsonnet-stdlib/src/sort.rs
@@ -113,11 +113,11 @@
 		return Ok(values);
 	}
 	if key_getter.is_identity() {
-		Ok(ArrValue::eager(sort_identity(
+		Ok(ArrValue::new(sort_identity(
 			values.iter().collect::<Result<Vec<Val>>>()?,
 		)?))
 	} else {
-		Ok(ArrValue::lazy(sort_keyf(values, key_getter)?))
+		Ok(ArrValue::new(sort_keyf(values, key_getter)?))
 	}
 }
 
@@ -162,11 +162,11 @@
 		return Ok(arr);
 	}
 	if keyF.is_identity() {
-		Ok(ArrValue::eager(uniq_identity(
+		Ok(ArrValue::new(uniq_identity(
 			arr.iter().collect::<Result<Vec<Val>>>()?,
 		)?))
 	} else {
-		Ok(ArrValue::lazy(uniq_keyf(arr, keyF)?))
+		Ok(ArrValue::new(uniq_keyf(arr, keyF)?))
 	}
 }
 
@@ -180,11 +180,11 @@
 		let arr = arr.iter().collect::<Result<Vec<Val>>>()?;
 		let arr = sort_identity(arr)?;
 		let arr = uniq_identity(arr)?;
-		Ok(ArrValue::eager(arr))
+		Ok(ArrValue::new(arr))
 	} else {
 		let arr = sort_keyf(arr, keyF.clone())?;
-		let arr = uniq_keyf(ArrValue::lazy(arr), keyF)?;
-		Ok(ArrValue::lazy(arr))
+		let arr = uniq_keyf(ArrValue::new(arr), keyF)?;
+		Ok(ArrValue::new(arr))
 	}
 }