git.delta.rocks / jrsonnet / refs/commits / 028057c85dc5

--- a/bindings/jsonnet/src/val_extract.rs
+++ b/bindings/jsonnet/src/val_extract.rs
@@ -9,7 +9,7 @@
 
 #[no_mangle]
 pub extern "C" fn jsonnet_json_extract_string(_vm: &EvaluationState, v: &Val) -> *mut c_char {
-	match v.unwrap_if_lazy().unwrap() {
+	match v {
 		Val::Str(s) => CString::new(&*s as &str).unwrap().into_raw(),
 		_ => std::ptr::null_mut(),
 	}
@@ -20,9 +20,9 @@
 	v: &Val,
 	out: &mut c_double,
 ) -> c_int {
-	match v.unwrap_if_lazy().unwrap() {
+	match v {
 		Val::Num(n) => {
-			*out = n;
+			*out = *n;
 			1
 		}
 		_ => 0,
@@ -30,7 +30,7 @@
 }
 #[no_mangle]
 pub extern "C" fn jsonnet_json_extract_bool(_vm: &EvaluationState, v: &Val) -> c_int {
-	match v.unwrap_if_lazy().unwrap() {
+	match v {
 		Val::Bool(false) => 0,
 		Val::Bool(true) => 1,
 		_ => 2,
@@ -38,7 +38,7 @@
 }
 #[no_mangle]
 pub extern "C" fn jsonnet_json_extract_null(_vm: &EvaluationState, v: &Val) -> c_int {
-	match v.unwrap_if_lazy().unwrap() {
+	match v {
 		Val::Null => 1,
 		_ => 0,
 	}

--- a/crates/jrsonnet-evaluator/src/builtin/format.rs
+++ b/crates/jrsonnet-evaluator/src/builtin/format.rs
@@ -1,7 +1,8 @@
 //! faster std.format impl
 #![allow(clippy::too_many_arguments)]
 
-use crate::{error::Error::*, throw, LocError, ObjValue, Result, Val, ValType};
+use crate::{error::Error::*, throw, LocError, ObjValue, Result, Val};
+use jrsonnet_types::ValType;
 use thiserror::Error;
 
 #[derive(Debug, Clone, Error)]
@@ -573,7 +574,7 @@
 				);
 			}
 		}
-		ConvTypeV::Char => match value.clone().unwrap_if_lazy()? {
+		ConvTypeV::Char => match value.clone() {
 			Val::Num(n) => tmp_out.push(
 				std::char::from_u32(n as u32)
 					.ok_or_else(|| InvalidUnicodeCodepointGot(n as u32))?,
@@ -590,7 +591,7 @@
 				throw!(TypeMismatch(
 					"%c requires number/string",
 					vec![ValType::Num, ValType::Str],
-					value.value_type()?,
+					value.value_type(),
 				));
 			}
 		},

--- a/crates/jrsonnet-evaluator/src/builtin/manifest.rs
+++ b/crates/jrsonnet-evaluator/src/builtin/manifest.rs
@@ -33,9 +33,9 @@
 ) -> Result<()> {
 	use std::fmt::Write;
 	let mtype = options.mtype;
-	match val.unwrap_if_lazy()? {
+	match val {
 		Val::Bool(v) => {
-			if v {
+			if *v {
 				buf.push_str("true");
 			} else {
 				buf.push_str("false");
@@ -63,7 +63,7 @@
 						}
 					}
 					buf.push_str(cur_padding);
-					manifest_json_ex_buf(item, buf, cur_padding, options)?;
+					manifest_json_ex_buf(&item?, buf, cur_padding, options)?;
 				}
 				cur_padding.truncate(old_len);
 
@@ -118,7 +118,6 @@
 			buf.push('}');
 		}
 		Val::Func(_) => throw!(RuntimeError("tried to manifest function".into())),
-		Val::Lazy(_) => unreachable!(),
 	};
 	Ok(())
 }

--- a/crates/jrsonnet-evaluator/src/builtin/sort.rs
+++ b/crates/jrsonnet-evaluator/src/builtin/sort.rs
@@ -46,7 +46,6 @@
 	let mut sort_type = SortKeyType::Unknown;
 	for i in values.iter_mut() {
 		let i = key_getter(i);
-		i.inplace_unwrap()?;
 		match (i, sort_type) {
 			(Val::Str(_), SortKeyType::Unknown) => sort_type = SortKeyType::String,
 			(Val::Num(_), SortKeyType::Unknown) => sort_type = SortKeyType::Number,

--- a/crates/jrsonnet-evaluator/src/evaluate.rs
+++ b/crates/jrsonnet-evaluator/src/evaluate.rs
@@ -1,7 +1,6 @@
 use crate::{
 	context_creator, error::Error::*, future_wrapper, lazy_val, push, throw, with_state, Context,
 	ContextCreator, FuncDesc, FuncVal, LazyBinding, LazyVal, ObjMember, ObjValue, Result, Val,
-	ValType,
 };
 use closure::closure;
 use jrsonnet_parser::{
@@ -9,6 +8,7 @@
 	ForSpecData, IfSpecData, LiteralType, LocExpr, Member, ObjBody, ParamsDesc, UnaryOpType,
 	Visibility,
 };
+use jrsonnet_types::ValType;
 use rustc_hash::FxHashMap;
 use std::{collections::HashMap, rc::Rc};
 
@@ -61,8 +61,7 @@
 	Ok(match field_name {
 		jrsonnet_parser::FieldName::Fixed(n) => Some(n.clone()),
 		jrsonnet_parser::FieldName::Dyn(expr) => {
-			let lazy = evaluate(context, expr)?;
-			let value = lazy.unwrap_if_lazy()?;
+			let value = evaluate(context, expr)?;
 			if matches!(value, Val::Null) {
 				None
 			} else {
@@ -74,11 +73,10 @@
 
 pub fn evaluate_unary_op(op: UnaryOpType, b: &Val) -> Result<Val> {
 	Ok(match (op, b) {
-		(o, Val::Lazy(l)) => evaluate_unary_op(o, &l.evaluate()?)?,
 		(UnaryOpType::Not, Val::Bool(v)) => Val::Bool(!v),
 		(UnaryOpType::Minus, Val::Num(n)) => Val::Num(-*n),
 		(UnaryOpType::BitNot, Val::Num(n)) => Val::Num(!(*n as i32) as f64),
-		(op, o) => throw!(UnaryOperatorDoesNotOperateOnType(op, o.value_type()?)),
+		(op, o) => throw!(UnaryOperatorDoesNotOperateOnType(op, o.value_type())),
 	})
 }
 
@@ -94,12 +92,17 @@
 		(o, Val::Str(s)) => Val::Str(format!("{}{}", o.clone().to_string()?, s).into()),
 
 		(Val::Obj(v1), Val::Obj(v2)) => Val::Obj(v2.with_super(v1.clone())),
-		(Val::Arr(a), Val::Arr(b)) => Val::Arr(Rc::new([&a[..], &b[..]].concat())),
+		(Val::Arr(a), Val::Arr(b)) => {
+			let mut out = Vec::with_capacity(a.len() + b.len());
+			out.extend(a.iter_lazy());
+			out.extend(b.iter_lazy());
+			Val::Arr(out.into())
+		}
 		(Val::Num(v1), Val::Num(v2)) => Val::new_checked_num(v1 + v2)?,
 		_ => throw!(BinaryOperatorDoesNotOperateOnValues(
 			BinaryOpType::Add,
-			a.value_type()?,
-			b.value_type()?,
+			a.value_type(),
+			b.value_type(),
 		)),
 	})
 }
@@ -110,15 +113,11 @@
 	op: BinaryOpType,
 	b: &LocExpr,
 ) -> Result<Val> {
-	Ok(
-		match (evaluate(context.clone(), a)?.unwrap_if_lazy()?, op, b) {
-			(Val::Bool(true), BinaryOpType::Or, _o) => Val::Bool(true),
-			(Val::Bool(false), BinaryOpType::And, _o) => Val::Bool(false),
-			(a, op, eb) => {
-				evaluate_binary_op_normal(&a, op, &evaluate(context, eb)?.unwrap_if_lazy()?)?
-			}
-		},
-	)
+	Ok(match (evaluate(context.clone(), a)?, op, b) {
+		(Val::Bool(true), BinaryOpType::Or, _o) => Val::Bool(true),
+		(Val::Bool(false), BinaryOpType::And, _o) => Val::Bool(false),
+		(a, op, eb) => evaluate_binary_op_normal(&a, op, &evaluate(context, eb)?)?,
+	})
 }
 
 pub fn evaluate_binary_op_normal(a: &Val, op: BinaryOpType, b: &Val) -> Result<Val> {
@@ -177,8 +176,8 @@
 
 		_ => throw!(BinaryOperatorDoesNotOperateOnValues(
 			op,
-			a.value_type()?,
-			b.value_type()?,
+			a.value_type(),
+			b.value_type(),
 		)),
 	})
 }
@@ -200,23 +199,20 @@
 				None
 			}
 		}
-		Some(CompSpec::ForSpec(ForSpecData(var, expr))) => {
-			match evaluate(context.clone(), expr)?.unwrap_if_lazy()? {
-				Val::Arr(list) => {
-					let mut out = Vec::new();
-					for item in list.iter() {
-						let item = item.unwrap_if_lazy()?;
-						out.push(evaluate_comp(
-							context.clone().with_var(var.clone(), item.clone()),
-							value,
-							&specs[1..],
-						)?);
-					}
-					Some(out.into_iter().flatten().flatten().collect())
+		Some(CompSpec::ForSpec(ForSpecData(var, expr))) => match evaluate(context.clone(), expr)? {
+			Val::Arr(list) => {
+				let mut out = Vec::new();
+				for item in list.iter() {
+					out.push(evaluate_comp(
+						context.clone().with_var(var.clone(), item?.clone()),
+						value,
+						&specs[1..],
+					)?);
 				}
-				_ => throw!(InComprehensionCanOnlyIterateOverArray),
+				Some(out.into_iter().flatten().flatten().collect())
 			}
-		}
+			_ => throw!(InComprehensionCanOnlyIterateOverArray),
+		},
 	})
 }
 
@@ -375,7 +371,7 @@
 							},
 						);
 					}
-					v => throw!(FieldMustBeStringGot(v.value_type()?)),
+					v => throw!(FieldMustBeStringGot(v.value_type())),
 				}
 			}
 
@@ -391,8 +387,7 @@
 	loc: &Option<ExprLocation>,
 	tailstrict: bool,
 ) -> Result<Val> {
-	let lazy = evaluate(context.clone(), value)?;
-	let value = lazy.unwrap_if_lazy()?;
+	let value = evaluate(context.clone(), value)?;
 	Ok(match value {
 		Val::Func(f) => {
 			let body = || f.evaluate(context, loc, args, tailstrict);
@@ -402,7 +397,7 @@
 				push(loc, || format!("function <{}> call", f.name()), body)?
 			}
 		}
-		v => throw!(OnlyFunctionsCanBeCalledGot(v.value_type()?)),
+		v => throw!(OnlyFunctionsCanBeCalledGot(v.value_type())),
 	})
 }
 
@@ -436,7 +431,7 @@
 		Var(name) => push(
 			loc,
 			|| format!("variable <{}>", name),
-			|| Ok(Val::Lazy(context.binding(name.clone())?).unwrap_if_lazy()?),
+			|| Ok(context.binding(name.clone())?.evaluate()?),
 		)?,
 		Index(LocExpr(v, _), index) if matches!(&**v, Expr::Literal(LiteralType::Super)) => {
 			let name = evaluate(context.clone(), index)?.try_cast_str("object index")?;
@@ -444,14 +439,11 @@
 				.super_obj()
 				.clone()
 				.expect("no super found")
-				.get_raw(name, &context.this().clone().expect("no this found"))?
+				.get_raw(name, Some(&context.this().clone().expect("no this found")))?
 				.expect("value not found")
 		}
 		Index(value, index) => {
-			match (
-				evaluate(context.clone(), value)?.unwrap_if_lazy()?,
-				evaluate(context, index)?,
-			) {
+			match (evaluate(context.clone(), value)?, evaluate(context, index)?) {
 				(Val::Obj(v), Val::Str(s)) => {
 					let sn = s.clone();
 					push(
@@ -459,7 +451,7 @@
 						|| format!("field <{}> access", sn),
 						|| {
 							if let Some(v) = v.get(s.clone())? {
-								Ok(v.unwrap_if_lazy()?)
+								Ok(v)
 							} else if v.get("__intrinsic_namespace__".into())?.is_some() {
 								Ok(Val::Func(Rc::new(FuncVal::Intrinsic(s))))
 							} else {
@@ -471,23 +463,22 @@
 				(Val::Obj(_), n) => throw!(ValueIndexMustBeTypeGot(
 					ValType::Obj,
 					ValType::Str,
-					n.value_type()?,
+					n.value_type(),
 				)),
 
 				(Val::Arr(v), Val::Num(n)) => {
 					if n.fract() > f64::EPSILON {
 						throw!(FractionalIndex)
 					}
-					v.get(n as usize)
+					v.get(n as usize)?
 						.ok_or_else(|| ArrayBoundsError(n as usize, v.len()))?
 						.clone()
-						.unwrap_if_lazy()?
 				}
 				(Val::Arr(_), Val::Str(n)) => throw!(AttemptedIndexAnArrayWithString(n)),
 				(Val::Arr(_), n) => throw!(ValueIndexMustBeTypeGot(
 					ValType::Arr,
 					ValType::Num,
-					n.value_type()?,
+					n.value_type(),
 				)),
 
 				(Val::Str(s), Val::Num(n)) => Val::Str(
@@ -500,10 +491,10 @@
 				(Val::Str(_), n) => throw!(ValueIndexMustBeTypeGot(
 					ValType::Str,
 					ValType::Num,
-					n.value_type()?,
+					n.value_type(),
 				)),
 
-				(v, _) => throw!(CantIndexInto(v.value_type()?)),
+				(v, _) => throw!(CantIndexInto(v.value_type())),
 			}
 		}
 		LocalExpr(bindings, returned) => {
@@ -529,17 +520,19 @@
 		Arr(items) => {
 			let mut out = Vec::with_capacity(items.len());
 			for item in items {
-				out.push(Val::Lazy(lazy_val!(
+				out.push(LazyVal::new(Box::new(
 					closure!(clone context, clone item, || {
 						evaluate(context.clone(), &item)
-					})
+					}),
 				)));
 			}
-			Val::Arr(Rc::new(out))
+			Val::Arr(out.into())
 		}
 		ArrComp(expr, comp_specs) => Val::Arr(
 			// First comp_spec should be for_spec, so no "None" possible here
-			Rc::new(evaluate_comp(context, &|ctx| evaluate(ctx, expr), comp_specs)?.unwrap()),
+			evaluate_comp(context, &|ctx| evaluate(ctx, expr), comp_specs)?
+				.unwrap()
+				.into(),
 		),
 		Obj(body) => Val::Obj(evaluate_object(context, body)?),
 		ObjExtend(s, t) => evaluate_add_op(

--- a/crates/jrsonnet-evaluator/src/integrations/serde.rs
+++ b/crates/jrsonnet-evaluator/src/integrations/serde.rs
@@ -22,11 +22,10 @@
 			} else {
 				Number::from_f64(*n).expect("to json number")
 			}),
-			Val::Lazy(v) => (&v.evaluate()?).try_into()?,
 			Val::Arr(a) => {
 				let mut out = Vec::with_capacity(a.len());
 				for item in a.iter() {
-					out.push(item.try_into()?);
+					out.push((&item?).try_into()?);
 				}
 				Self::Array(out)
 			}
@@ -55,9 +54,9 @@
 			Value::Array(a) => {
 				let mut out = Vec::with_capacity(a.len());
 				for v in a {
-					out.push(v.into());
+					out.push(LazyVal::new_resolved(v.into()));
 				}
-				Self::Arr(Rc::new(out))
+				Self::Arr(out.into())
 			}
 			Value::Object(o) => {
 				let mut entries = HashMap::with_capacity(o.len());

--- a/crates/jrsonnet-evaluator/src/obj.rs
+++ b/crates/jrsonnet-evaluator/src/obj.rs
@@ -102,9 +102,10 @@
 		visible_fields
 	}
 	pub fn get(&self, key: Rc<str>) -> Result<Option<Val>> {
-		Ok(self.get_raw(key, self)?)
+		Ok(self.get_raw(key, None)?)
 	}
-	pub(crate) fn get_raw(&self, key: Rc<str>, real_this: &Self) -> Result<Option<Val>> {
+	pub(crate) fn get_raw(&self, key: Rc<str>, real_this: Option<&Self>) -> Result<Option<Val>> {
+		let real_this = real_this.unwrap_or(self);
 		let cache_key = (key.clone(), Rc::as_ptr(&real_this.0) as usize);
 
 		if let Some(v) = self.0.value_cache.borrow().get(&cache_key) {
@@ -115,7 +116,7 @@
 			(Some(k), Some(s)) => {
 				let our = self.evaluate_this(k, real_this)?;
 				if k.add {
-					s.get_raw(key, real_this)?
+					s.get_raw(key, Some(real_this))?
 						.map_or(Ok(Some(our.clone())), |v| {
 							Ok(Some(evaluate_add_op(&v, &our)?))
 						})
@@ -123,7 +124,7 @@
 					Ok(Some(our))
 				}
 			}
-			(None, Some(s)) => s.get_raw(key, real_this),
+			(None, Some(s)) => s.get_raw(key, Some(real_this)),
 			(None, None) => Ok(None),
 		}?;
 		self.0

10	throw, with_state, Context, ObjValue, Result,10	throw, with_state, Context, ObjValue, Result,
11};11};
12use jrsonnet_parser::{el, Arg, ArgsDesc, Expr, ExprLocation, LiteralType, LocExpr, ParamsDesc};12use jrsonnet_parser::{el, Arg, ArgsDesc, Expr, ExprLocation, LiteralType, LocExpr, ParamsDesc};
13use jrsonnet_types::ValType;
13use std::{14use std::{cell::RefCell, collections::HashMap, fmt::Debug, rc::Rc};
14	cell::RefCell,
15	collections::HashMap,
16	fmt::{Debug, Display},
17	rc::Rc,
18};
1915
20enum LazyValInternals {16enum LazyValInternals {
166	}162	}
167}163}
168
169#[derive(Debug, Clone, Copy, PartialEq)]
170pub enum ValType {
171	Bool,
172	Null,
173	Str,
174	Num,
175	Arr,
176	Obj,
177	Func,
178}
179impl ValType {
180	pub const fn name(&self) -> &'static str {
181		use ValType::*;
182		match self {
183			Bool => "boolean",
184			Null => "null",
185			Str => "string",
186			Num => "number",
187			Arr => "array",
188			Obj => "object",
189			Func => "function",
190		}
191	}
192}
193impl Display for ValType {
194	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
195		write!(f, "{}", self.name())
196	}
197}
198164
199#[derive(Clone)]165#[derive(Clone)]
200pub enum ManifestFormat {166pub enum ManifestFormat {
205	String,171	String,
206}172}
173
174#[derive(Debug, Clone)]
175pub enum ArrValue {
176	Lazy(Rc<Vec<LazyVal>>),
177	Eager(Rc<Vec<Val>>),
178}
179impl ArrValue {
180	pub fn len(&self) -> usize {
181		match self {
182			ArrValue::Lazy(l) => l.len(),
183			ArrValue::Eager(e) => e.len(),
184		}
185	}
186
187	pub fn is_empty(&self) -> bool {
188		self.len() == 0
189	}
190
191	pub fn get(&self, index: usize) -> Result<Option<Val>> {
192		match self {
193			ArrValue::Lazy(vec) => {
194				if let Some(v) = vec.get(index) {
195					Ok(Some(v.evaluate()?))
196				} else {
197					Ok(None)
198				}
199			}
200			ArrValue::Eager(vec) => Ok(vec.get(index).cloned()),
201		}
202	}
203
204	pub fn get_lazy(&self, index: usize) -> Option<LazyVal> {
205		match self {
206			ArrValue::Lazy(vec) => vec.get(index).cloned(),
207			ArrValue::Eager(vec) => vec
208				.get(index)
209				.cloned()
210				.map(|val| LazyVal::new_resolved(val)),
211		}
212	}
213
214	pub fn evaluated(&self) -> Result<Rc<Vec<Val>>> {
215		Ok(match self {
216			ArrValue::Lazy(vec) => {
217				let mut out = Vec::with_capacity(vec.len());
218				for item in vec.iter() {
219					out.push(item.evaluate()?);
220				}
221				Rc::new(out)
222			}
223			ArrValue::Eager(vec) => vec.clone(),
224		})
225	}
226
227	pub fn iter(&self) -> impl DoubleEndedIterator<Item = Result<Val>> + '_ {
228		(0..self.len()).map(move |idx| match self {
229			ArrValue::Lazy(l) => l[idx].evaluate(),
230			ArrValue::Eager(e) => Ok(e[idx].clone()),
231		})
232	}
233
234	pub fn iter_lazy(&self) -> impl DoubleEndedIterator<Item = LazyVal> + '_ {
235		(0..self.len()).map(move |idx| match self {
236			ArrValue::Lazy(l) => l[idx].clone(),
237			ArrValue::Eager(e) => LazyVal::new_resolved(e[idx].clone()),
238		})
239	}
240
241	pub fn reversed(self) -> Self {
242		match self {
243			ArrValue::Lazy(vec) => {
244				let mut out = (&vec as &Vec<_>).clone();
245				out.reverse();
246				Self::Lazy(Rc::new(out))
247			}
248			ArrValue::Eager(vec) => {
249				let mut out = (&vec as &Vec<_>).clone();
250				out.reverse();
251				Self::Eager(Rc::new(out))
252			}
253		}
254	}
255}
256
257impl From<Vec<LazyVal>> for ArrValue {
258	fn from(v: Vec<LazyVal>) -> Self {
259		Self::Lazy(Rc::new(v))
260	}
261}
262
263impl From<Vec<Val>> for ArrValue {
264	fn from(v: Vec<Val>) -> Self {
265		Self::Eager(Rc::new(v))
266	}
267}
207268
208#[derive(Debug, Clone)]269#[derive(Debug, Clone)]
209pub enum Val {270pub enum Val {
210	Bool(bool),271	Bool(bool),
211	Null,272	Null,
212	Str(Rc<str>),273	Str(Rc<str>),
213	Num(f64),274	Num(f64),
214	Lazy(LazyVal),
215	Arr(Rc<Vec<Val>>),275	Arr(ArrValue),
216	Obj(ObjValue),276	Obj(ObjValue),
217	Func(Rc<FuncVal>),277	Func(Rc<FuncVal>),
218}278}
237	}297	}
238298
239	pub fn assert_type(&self, context: &'static str, val_type: ValType) -> Result<()> {299	pub fn assert_type(&self, context: &'static str, val_type: ValType) -> Result<()> {
240		let this_type = self.value_type()?;300		let this_type = self.value_type();
241		if this_type != val_type {301		if this_type != val_type {
242			throw!(TypeMismatch(context, vec![val_type], this_type))302			throw!(TypeMismatch(context, vec![val_type], this_type))
243		} else {303		} else {
244			Ok(())304			Ok(())
245		}305		}
246	}306	}
307	pub fn unwrap_num(self) -> Result<f64> {
308		Ok(matches_unwrap!(self, Self::Num(v), v))
309	}
310	pub fn unwrap_func(self) -> Result<Rc<FuncVal>> {
311		Ok(matches_unwrap!(self, Self::Func(v), v))
312	}
247	pub fn try_cast_bool(self, context: &'static str) -> Result<bool> {313	pub fn try_cast_bool(self, context: &'static str) -> Result<bool> {
248		self.assert_type(context, ValType::Bool)?;314		self.assert_type(context, ValType::Bool)?;
249		Ok(matches_unwrap!(self.unwrap_if_lazy()?, Self::Bool(v), v))315		Ok(matches_unwrap!(self, Self::Bool(v), v))
250	}316	}
251	pub fn try_cast_str(self, context: &'static str) -> Result<Rc<str>> {317	pub fn try_cast_str(self, context: &'static str) -> Result<Rc<str>> {
252		self.assert_type(context, ValType::Str)?;318		self.assert_type(context, ValType::Str)?;
253		Ok(matches_unwrap!(self.unwrap_if_lazy()?, Self::Str(v), v))319		Ok(matches_unwrap!(self, Self::Str(v), v))
254	}320	}
255	pub fn try_cast_num(self, context: &'static str) -> Result<f64> {321	pub fn try_cast_num(self, context: &'static str) -> Result<f64> {
256		self.assert_type(context, ValType::Num)?;322		self.assert_type(context, ValType::Num)?;
257		Ok(matches_unwrap!(self.unwrap_if_lazy()?, Self::Num(v), v))323		self.unwrap_num()
258	}324	}
259	pub fn inplace_unwrap(&mut self) -> Result<()> {
260		while let Self::Lazy(lazy) = self {
261			*self = lazy.evaluate()?;
262		}
263		Ok(())
264	}
265	pub fn unwrap_if_lazy(&self) -> Result<Self> {
266		Ok(if let Self::Lazy(v) = self {
267			v.evaluate()?.unwrap_if_lazy()?
268		} else {
269			self.clone()
270		})
271	}
272	pub fn value_type(&self) -> Result<ValType> {325	pub fn value_type(&self) -> ValType {
273		Ok(match self {326		match self {
274			Self::Str(..) => ValType::Str,327			Self::Str(..) => ValType::Str,
275			Self::Num(..) => ValType::Num,328			Self::Num(..) => ValType::Num,
276			Self::Arr(..) => ValType::Arr,329			Self::Arr(..) => ValType::Arr,
277			Self::Obj(..) => ValType::Obj,330			Self::Obj(..) => ValType::Obj,
278			Self::Bool(_) => ValType::Bool,331			Self::Bool(_) => ValType::Bool,
279			Self::Null => ValType::Null,332			Self::Null => ValType::Null,
280			Self::Func(..) => ValType::Func,333			Self::Func(..) => ValType::Func,
281			Self::Lazy(_) => self.clone().unwrap_if_lazy()?.value_type()?,
282		})334		}
283	}335	}
284336
285	pub fn to_string(&self) -> Result<Rc<str>> {337	pub fn to_string(&self) -> Result<Rc<str>> {
286		Ok(match self.unwrap_if_lazy()? {338		Ok(match self {
287			Self::Bool(true) => "true".into(),339			Self::Bool(true) => "true".into(),
288			Self::Bool(false) => "false".into(),340			Self::Bool(false) => "false".into(),
289			Self::Null => "null".into(),341			Self::Null => "null".into(),
290			Self::Str(s) => s,342			Self::Str(s) => s.clone(),
291			v => manifest_json_ex(343			v => manifest_json_ex(
292				&v,344				&v,
293				&ManifestJsonOptions {345				&ManifestJsonOptions {
325		};377		};
326		let mut out = Vec::with_capacity(arr.len());378		let mut out = Vec::with_capacity(arr.len());
327		for i in arr.iter() {379		for i in arr.iter() {
328			out.push(i.manifest(ty)?);380			out.push(i?.manifest(ty)?);
329		}381		}
330		Ok(out)382		Ok(out)
331	}383	}
348				if !arr.is_empty() {400				if !arr.is_empty() {
349					for v in arr.iter() {401					for v in arr.iter() {
350						out.push_str("---\n");402						out.push_str("---\n");
351						out.push_str(&v.manifest(format)?);403						out.push_str(&v?.manifest(format)?);
352						out.push('\n');404						out.push('\n');
353					}405					}
354					out.push_str("...");406					out.push_str("...");
456508
457/// Native implementation of `std.primitiveEquals`509/// Native implementation of `std.primitiveEquals`
458pub fn primitive_equals(val_a: &Val, val_b: &Val) -> Result<bool> {510pub fn primitive_equals(val_a: &Val, val_b: &Val) -> Result<bool> {
459	Ok(match (val_a.unwrap_if_lazy()?, val_b.unwrap_if_lazy()?) {511	Ok(match (val_a, val_b) {
460		(Val::Bool(a), Val::Bool(b)) => a == b,512		(Val::Bool(a), Val::Bool(b)) => a == b,
461		(Val::Null, Val::Null) => true,513		(Val::Null, Val::Null) => true,
462		(Val::Str(a), Val::Str(b)) => a == b,514		(Val::Str(a), Val::Str(b)) => a == b,
476528
477/// Native implementation of `std.equals`529/// Native implementation of `std.equals`
478pub fn equals(val_a: &Val, val_b: &Val) -> Result<bool> {530pub fn equals(val_a: &Val, val_b: &Val) -> Result<bool> {
479	let val_a = val_a.unwrap_if_lazy()?;
480	let val_b = val_b.unwrap_if_lazy()?;
481
482	if val_a.value_type()? != val_b.value_type()? {531	if val_a.value_type() != val_b.value_type() {
483		return Ok(false);532		return Ok(false);
484	}533	}
485	match (val_a, val_b) {534	match (val_a, val_b) {
489				return Ok(false);538				return Ok(false);
490			}539			}
491			for (a, b) in a.iter().zip(b.iter()) {540			for (a, b) in a.iter().zip(b.iter()) {
492				if !equals(&a.unwrap_if_lazy()?, &b.unwrap_if_lazy()?)? {541				if !equals(&a?, &b?)? {
493					return Ok(false);542					return Ok(false);
494				}543				}
495			}544			}

--- a/crates/jrsonnet-parser/src/expr.rs
+++ b/crates/jrsonnet-parser/src/expr.rs
@@ -97,6 +97,7 @@
 	Mul,
 	Div,
 
+	/// Implemented as intrinsic, put here for completeness
 	Mod,
 
 	Add,