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<_>>())
 	}
 }

1use std::{any::Any, cell::RefCell, fmt::Debug, mem::replace, rc::Rc};1use std::{
2	any::Any,
3	cell::RefCell,
4	fmt::{self, Debug},
5	mem::replace,
6	rc::Rc,
7};
28
3use jrsonnet_gcmodule::{Cc, Trace};9use jrsonnet_gcmodule::{Cc, Trace};
21	}27	}
22	fn get(&self, index: usize) -> Result<Option<Val>>;28	fn get(&self, index: usize) -> Result<Option<Val>>;
23	fn get_lazy(&self, index: usize) -> Option<Thunk<Val>>;29	fn get_lazy(&self, index: usize) -> Option<Thunk<Val>>;
24	fn get_cheap(&self, index: usize) -> Option<Val>;
2530
26	fn is_cheap(&self) -> bool;31	fn is_cheap(&self) -> bool {
32		false
33	}
27}34}
35trait ArrayCheap {
36	fn get(&self, index: usize) -> Option<Val>;
37	fn len(&self) -> usize;
38}
39impl<T> ArrayLike for T
40where
41	T: Any + Trace + Debug + ArrayCheap,
42{
43	fn len(&self) -> usize {
44		<T as ArrayCheap>::len(self)
45	}
46
47	fn get(&self, index: usize) -> Result<Option<Val>> {
48		Ok(<T as ArrayCheap>::get(self, index))
49	}
50
51	fn get_lazy(&self, index: usize) -> Option<Thunk<Val>> {
52		<T as ArrayCheap>::get(self, index).map(Thunk::evaluated)
53	}
54
55	fn is_cheap(&self) -> bool {
56		true
57	}
58}
59
60impl ArrayCheap for () {
61	fn len(&self) -> usize {
62		0
63	}
64	fn get(&self, _index: usize) -> Option<Val> {
65		None
66	}
67}
2868
29#[derive(Debug, Trace)]69#[derive(Debug, Trace)]
30pub struct SliceArray {70pub struct SliceArray {
52		self.inner.get_lazy(self.map_idx(index))92		self.inner.get_lazy(self.map_idx(index))
53	}93	}
5494
55	fn get_cheap(&self, index: usize) -> Option<Val> {
56		self.inner.get_cheap(self.map_idx(index))
57	}
58	fn is_cheap(&self) -> bool {95	fn is_cheap(&self) -> bool {
59		self.inner.is_cheap()96		self.inner.is_cheap()
60	}97	}
61}98}
6299
63#[derive(Trace, Debug)]100#[derive(Trace, Debug)]
64pub struct CharArray(pub Vec<char>);101pub struct CharArray(pub Vec<char>);
65impl ArrayLike for CharArray {102impl ArrayCheap for CharArray {
66	fn len(&self) -> usize {103	fn len(&self) -> usize {
67		self.0.len()104		self.0.as_slice().len()
68	}105	}
69
70	fn get(&self, index: usize) -> Result<Option<Val>> {106	fn get(&self, index: usize) -> Option<Val> {
71		Ok(self.get_cheap(index))
72	}
73
74	fn get_lazy(&self, index: usize) -> Option<Thunk<Val>> {
75		self.get_cheap(index).map(Thunk::evaluated)
76	}
77
78	fn get_cheap(&self, index: usize) -> Option<Val> {
79		self.0.get(index).map(|v| Val::string(*v))107		self.0.as_slice().get(index).map(|v| Val::string(*v))
80	}108	}
81	fn is_cheap(&self) -> bool {
82		true
83	}
84}109}
85110
86#[derive(Trace, Debug)]
87pub struct BytesArray(pub IBytes);
88impl ArrayLike for BytesArray {111impl ArrayCheap for IBytes {
89	fn len(&self) -> usize {112	fn len(&self) -> usize {
90		self.0.len()113		self.as_slice().len()
91	}114	}
92
93	fn get(&self, index: usize) -> Result<Option<Val>> {115	fn get(&self, index: usize) -> Option<Val> {
94		Ok(self.get_cheap(index))
95	}
96
97	fn get_lazy(&self, index: usize) -> Option<Thunk<Val>> {
98		self.get_cheap(index).map(Thunk::evaluated)
99	}
100
101	fn get_cheap(&self, index: usize) -> Option<Val> {
102		self.0.get(index).map(|v| Val::Num((*v).into()))116		self.as_slice().get(index).map(|v| Val::Num((*v).into()))
103	}117	}
104	fn is_cheap(&self) -> bool {
105		true
106	}
107}118}
108119
109#[derive(Debug, Trace, Clone)]120#[derive(Debug, Trace, Clone)]
191			index,202			index,
192		}))203		}))
193	}204	}
194	fn get_cheap(&self, _index: usize) -> Option<Val> {
195		None
196	}
197	fn is_cheap(&self) -> bool {205	fn is_cheap(&self) -> bool {
198		false206		false
199	}207	}
275		self.len283		self.len
276	}284	}
277285
278	fn get_cheap(&self, index: usize) -> Option<Val> {
279		if self.split > index {
280			self.a.get_cheap(index)
281		} else {
282			self.b.get_cheap(index - self.split)
283		}
284	}
285	fn is_cheap(&self) -> bool {286	fn is_cheap(&self) -> bool {
286		self.a.is_cheap() && self.b.is_cheap()287		self.a.is_cheap() && self.b.is_cheap()
287	}288	}
288}289}
289290
290#[derive(Trace, Debug)]
291pub struct LazyArray(pub Vec<Thunk<Val>>);
292impl ArrayLike for LazyArray {291impl<T> ArrayLike for Vec<T>
292where
293	T: IntoUntyped + Trace + fmt::Debug,
294	for<'a> &'a T: IntoUntyped,
295{
293	fn len(&self) -> usize {296	fn len(&self) -> usize {
294		self.0.len()297		self.as_slice().len()
295	}298	}
299
296	fn get(&self, index: usize) -> Result<Option<Val>> {300	fn get(&self, index: usize) -> Result<Option<Val>> {
297		let Some(v) = self.0.get(index) else {301		let Some(elem) = self.as_slice().get(index) else {
298			return Ok(None);302			return Ok(None);
299		};303		};
300		v.evaluate().map(Some)304		IntoUntyped::into_untyped(elem).map(Some)
301	}305	}
302	fn get_cheap(&self, _index: usize) -> Option<Val> {306
303		None
304	}
305	fn get_lazy(&self, index: usize) -> Option<Thunk<Val>> {307	fn get_lazy(&self, index: usize) -> Option<Thunk<Val>> {
306		self.0.get(index).cloned()308		let elem = self.as_slice().get(index)?;
309		Some(IntoUntyped::into_lazy_untyped(elem))
307	}310	}
311
308	fn is_cheap(&self) -> bool {312	fn is_cheap(&self) -> bool {
309		false313		!T::provides_lazy()
310	}314	}
311}315}
312
313#[derive(Trace, Debug)]
314pub struct EagerArray(pub Vec<Val>);
315impl ArrayLike for EagerArray {
316	fn len(&self) -> usize {
317		self.0.len()
318	}
319
320	fn get(&self, index: usize) -> Result<Option<Val>> {
321		Ok(self.0.get(index).cloned())
322	}
323
324	fn get_lazy(&self, index: usize) -> Option<Thunk<Val>> {
325		self.0.get(index).cloned().map(Thunk::evaluated)
326	}
327
328	fn get_cheap(&self, index: usize) -> Option<Val> {
329		self.0.get(index).cloned()
330	}
331	fn is_cheap(&self) -> bool {
332		true
333	}
334}
335316
336/// Inclusive range type317/// Inclusive range type
337#[derive(Debug, Trace, PartialEq, Eq)]318#[derive(Debug, Trace, PartialEq, Eq)]
364	}345	}
365}346}
366
367impl ArrayLike for RangeArray {347impl ArrayCheap for RangeArray {
368	fn len(&self) -> usize {
369		self.size()
370	}
371	fn is_empty(&self) -> bool {
372		self.size() == 0
373	}
374
375	fn get(&self, index: usize) -> Result<Option<Val>> {
376		Ok(self.get_cheap(index))
377	}
378
379	fn get_lazy(&self, index: usize) -> Option<Thunk<Val>> {
380		self.get_cheap(index).map(Thunk::evaluated)
381	}
382
383	fn get_cheap(&self, index: usize) -> Option<Val> {348	fn get(&self, index: usize) -> Option<Val> {
384		self.range().nth(index).map(|i| Val::Num(i.into()))349		self.range().nth(index).map(|i| Val::Num(i.into()))
385	}350	}
386	fn is_cheap(&self) -> bool {351	fn len(&self) -> usize {
387		true352		self.size()
388	}353	}
389}354}
390355
403		self.0.get_lazy(self.0.len() - index - 1)368		self.0.get_lazy(self.0.len() - index - 1)
404	}369	}
405370
406	fn get_cheap(&self, index: usize) -> Option<Val> {
407		self.0.get_cheap(self.0.len() - index - 1)
408	}
409	fn is_cheap(&self) -> bool {371	fn is_cheap(&self) -> bool {
410		self.0.is_cheap()372		self.0.is_cheap()
411	}373	}
511		}))473		}))
512	}474	}
513
514	fn get_cheap(&self, _index: usize) -> Option<Val> {
515		None
516	}
517	fn is_cheap(&self) -> bool {
518		false
519	}
520}475}
521476
522#[derive(Trace, Debug)]477#[derive(Trace, Debug)]
525	repeats: usize,480	repeats: usize,
526	total_len: usize,481	total_len: usize,
527}482}
528impl RepeatedArray {483impl RepeatedArray {
529	pub fn new(data: ArrValue, repeats: usize) -> Option<Self> {484	pub fn new(data: ArrValue, repeats: usize) -> Option<Self> {
530		let total_len = data.len().checked_mul(repeats)?;485		let total_len = data.len().checked_mul(repeats)?;
531		Some(Self {486		Some(Self {
534			total_len,489			total_len,
535		})490		})
536	}491	}
537}
538
539impl ArrayLike for RepeatedArray {
540	fn len(&self) -> usize {
541		self.total_len
542	}
543
544	fn get(&self, index: usize) -> Result<Option<Val>> {492	fn map_idx(&self, index: usize) -> Option<usize> {
545		if index > self.total_len {493		if index > self.total_len {
546			return Ok(None);494			return None;
547		}495		}
548		self.data.get(index % self.data.len())496		Some(index % self.data.len())
549	}497	}
498}
499
500impl ArrayLike for RepeatedArray {
501	fn len(&self) -> usize {
502		self.total_len
503	}
550504
551	fn get_lazy(&self, index: usize) -> Option<Thunk<Val>> {505	fn get(&self, index: usize) -> Result<Option<Val>> {
552		if index > self.total_len {506		let Some(idx) = self.map_idx(index) else {
553			return None;507			return Ok(None);
554		}508		};
555		self.data.get_lazy(index % self.data.len())509		self.data.get(idx)
556	}510	}
557511
558	fn get_cheap(&self, index: usize) -> Option<Val> {512	fn get_lazy(&self, index: usize) -> Option<Thunk<Val>> {
559		if index > self.total_len {513		let idx = self.map_idx(index)?;
560			return None;
561		}
562		self.data.get_cheap(index % self.data.len())514		self.data.get_lazy(idx)
563	}515	}
516
564	fn is_cheap(&self) -> bool {517	fn is_cheap(&self) -> bool {
565		self.data.is_cheap()518		self.data.is_cheap()
566	}519	}
567}520}
568521
569#[derive(Trace, Debug)]522#[derive(Trace, Debug)]
570pub struct PickObjectValues {523pub struct PickObjectValues {
584	}537	}
585538
586	fn get(&self, index: usize) -> Result<Option<Val>> {539	fn get(&self, index: usize) -> Result<Option<Val>> {
587		let Some(key) = self.keys.get(index) else {540		let Some(key) = self.keys.as_slice().get(index) else {
588			return Ok(None);541			return Ok(None);
589		};542		};
590		Ok(Some(self.obj.get_or_bail(key.clone())?))543		Ok(Some(self.obj.get_or_bail(key.clone())?))
591	}544	}
592545
593	fn get_lazy(&self, index: usize) -> Option<Thunk<Val>> {546	fn get_lazy(&self, index: usize) -> Option<Thunk<Val>> {
594		let key = self.keys.get(index)?;547		let key = self.keys.as_slice().get(index)?;
595		Some(self.obj.get_lazy_or_bail(key.clone()))548		Some(self.obj.get_lazy_or_bail(key.clone()))
596	}549	}
597
598	fn get_cheap(&self, _index: usize) -> Option<Val> {
599		None
600	}
601550
602	fn is_cheap(&self) -> bool {551	fn is_cheap(&self) -> bool {
603		false552		false
628	}577	}
629578
630	fn get(&self, index: usize) -> Result<Option<Val>> {579	fn get(&self, index: usize) -> Result<Option<Val>> {
631		let Some(key) = self.keys.get(index) else {580		let Some(key) = self.keys.as_slice().get(index) else {
632			return Ok(None);581			return Ok(None);
633		};582		};
634		Ok(Some(583		Ok(Some(
641	}590	}
642591
643	fn get_lazy(&self, index: usize) -> Option<Thunk<Val>> {592	fn get_lazy(&self, index: usize) -> Option<Thunk<Val>> {
644		let key = self.keys.get(index)?;593		let key = self.keys.as_slice().get(index)?;
645		// Nothing can fail in the key part, yet value is still594		// Nothing can fail in the key part, yet value is still
646		// lazy-evaluated595		// lazy-evaluated
647		Some(Thunk::evaluated(596		Some(Thunk::evaluated(
653		))602		))
654	}603	}
655
656	fn get_cheap(&self, _index: usize) -> Option<Val> {
657		None
658	}
659604
660	fn is_cheap(&self) -> bool {605	fn is_cheap(&self) -> bool {
661		false606		false

--- 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/integrations/serde.rs
+++ b/crates/jrsonnet-evaluator/src/integrations/serde.rs
@@ -1,6 +1,6 @@
 use std::borrow::Cow;
 
-use jrsonnet_interner::IStr;
+use jrsonnet_interner::{IBytes, IStr};
 use serde::{
 	Deserialize, Serialize, Serializer,
 	de::{self, Visitor},
@@ -11,8 +11,8 @@
 };
 
 use crate::{
-	Error as JrError, ObjValue, ObjValueBuilder, Result, Val, arr::ArrValue, in_description_frame,
-	runtime_error, val::NumValue,
+	Error as JrError, ObjValue, ObjValueBuilder, Result, Val, in_description_frame, runtime_error,
+	val::NumValue,
 };
 
 impl<'de> Deserialize<'de> for Val {
@@ -90,7 +90,7 @@
 			where
 				E: de::Error,
 			{
-				Ok(Val::Arr(ArrValue::bytes(v.into())))
+				Ok(Val::arr(IBytes::from(v)))
 			}
 
 			fn visit_none<E>(self) -> Result<Self::Value, E>
@@ -130,7 +130,7 @@
 					out.push(val);
 				}
 
-				Ok(Val::Arr(ArrValue::eager(out)))
+				Ok(Val::arr(out))
 			}
 
 			fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
@@ -270,7 +270,7 @@
 	}
 
 	fn end(self) -> Result<Val> {
-		let inner = Val::Arr(ArrValue::eager(self.data));
+		let inner = Val::arr(self.data);
 		if let Some(variant) = self.variant {
 			let mut out = ObjValue::builder_with_capacity(1);
 			out.field(variant).value(inner);
@@ -509,7 +509,7 @@
 	}
 
 	fn serialize_bytes(self, v: &[u8]) -> Result<Val> {
-		Ok(Val::Arr(ArrValue::bytes(v.into())))
+		Ok(Val::arr(IBytes::from(v)))
 	}
 
 	fn serialize_none(self) -> 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))
 	}
 }