git.delta.rocks / jrsonnet / refs/commits / 88a0ba11fe45

--- a/bindings/jsonnet/src/native.rs
+++ b/bindings/jsonnet/src/native.rs
@@ -9,7 +9,7 @@
 use jrsonnet_evaluator::{
 	error::{Error, LocError},
 	function::builtin::{BuiltinParam, NativeCallback, NativeCallbackHandler},
-	gc::TraceBox,
+	tb,
 	typed::Typed,
 	IStr, State, Val,
 };
@@ -78,9 +78,9 @@
 	vm.add_native(
 		name,
 		#[allow(deprecated)]
-		Cc::new(TraceBox(Box::new(NativeCallback::new(
+		Cc::new(tb!(NativeCallback::new(
 			params,
-			TraceBox(Box::new(JsonnetNativeCallbackHandler { ctx, cb })),
-		)))),
+			tb!(JsonnetNativeCallbackHandler { ctx, cb }),
+		))),
 	)
 }

--- a/bindings/jsonnet/src/val_modify.rs
+++ b/bindings/jsonnet/src/val_modify.rs
@@ -5,7 +5,7 @@
 use std::{ffi::CStr, os::raw::c_char};
 
 use gcmodule::Cc;
-use jrsonnet_evaluator::{val::ArrValue, LazyVal, State, Val};
+use jrsonnet_evaluator::{val::ArrValue, State, Thunk, Val};
 
 /// # Safety
 ///
@@ -18,7 +18,8 @@
 			for item in old.iter_lazy() {
 				new.push(item);
 			}
-			new.push(LazyVal::new_resolved(val.clone()));
+
+			new.push(Thunk::evaluated(val.clone()));
 			*arr = Val::Arr(ArrValue::Lazy(Cc::new(new)));
 		}
 		_ => panic!("should receive array"),

--- a/cmds/jrsonnet/Cargo.toml
+++ b/cmds/jrsonnet/Cargo.toml
@@ -16,6 +16,8 @@
     "jrsonnet-evaluator/exp-serde-preserve-order",
     "jrsonnet-cli/exp-preserve-order",
 ]
+# Destructuring of locals
+exp-destruct = ["jrsonnet-evaluator/exp-destruct"]
 
 [dependencies]
 jrsonnet-evaluator = { path = "../../crates/jrsonnet-evaluator", version = "0.4.2" }

--- a/crates/jrsonnet-evaluator/Cargo.toml
+++ b/crates/jrsonnet-evaluator/Cargo.toml
@@ -18,6 +18,8 @@
 # Allows to preserve field order in objects
 exp-preserve-order = []
 exp-serde-preserve-order = ["serde_json/preserve_order"]
+# Implements field destructuring
+exp-destruct = []
 
 [dependencies]
 jrsonnet-interner = { path = "../jrsonnet-interner", version = "0.4.2" }

--- a/crates/jrsonnet-evaluator/src/ctx.rs
+++ b/crates/jrsonnet-evaluator/src/ctx.rs
@@ -4,12 +4,12 @@
 use jrsonnet_interner::IStr;
 
 use crate::{
-	cc_ptr_eq, error::Error::*, gc::GcHashMap, map::LayeredHashMap, FutureWrapper, LazyBinding,
-	LazyVal, ObjValue, Result, State, Val,
+	cc_ptr_eq, error::Error::*, gc::GcHashMap, map::LayeredHashMap, LazyBinding, ObjValue, Pending,
+	Result, State, Thunk, Val,
 };
 
 #[derive(Clone, Trace)]
-pub struct ContextCreator(pub Context, pub FutureWrapper<GcHashMap<IStr, LazyBinding>>);
+pub struct ContextCreator(pub Context, pub Pending<GcHashMap<IStr, LazyBinding>>);
 impl ContextCreator {
 	pub fn create(
 		&self,
@@ -43,8 +43,8 @@
 #[derive(Debug, Clone, Trace)]
 pub struct Context(Cc<ContextInternals>);
 impl Context {
-	pub fn new_future() -> FutureWrapper<Self> {
-		FutureWrapper::new()
+	pub fn new_future() -> Pending<Self> {
+		Pending::new()
 	}
 
 	pub fn dollar(&self) -> &Option<ObjValue> {
@@ -68,7 +68,7 @@
 		}))
 	}
 
-	pub fn binding(&self, name: IStr) -> Result<LazyVal> {
+	pub fn binding(&self, name: IStr) -> Result<Thunk<Val>> {
 		Ok(self
 			.0
 			.bindings
@@ -80,7 +80,7 @@
 		self.0.bindings.contains_key(&name)
 	}
 	#[must_use]
-	pub fn into_future(self, ctx: FutureWrapper<Self>) -> Self {
+	pub fn into_future(self, ctx: Pending<Self>) -> Self {
 		{
 			ctx.0.borrow_mut().replace(self);
 		}
@@ -90,7 +90,7 @@
 	#[must_use]
 	pub fn with_var(self, name: IStr, value: Val) -> Self {
 		let mut new_bindings = GcHashMap::with_capacity(1);
-		new_bindings.insert(name, LazyVal::new_resolved(value));
+		new_bindings.insert(name, Thunk::evaluated(value));
 		self.extend(new_bindings, None, None, None)
 	}
 
@@ -102,7 +102,7 @@
 	#[must_use]
 	pub fn extend(
 		self,
-		new_bindings: GcHashMap<IStr, LazyVal>,
+		new_bindings: GcHashMap<IStr, Thunk<Val>>,
 		new_dollar: Option<ObjValue>,
 		new_this: Option<ObjValue>,
 		new_super_obj: Option<ObjValue>,
@@ -124,7 +124,7 @@
 		}))
 	}
 	#[must_use]
-	pub fn extend_bound(self, new_bindings: GcHashMap<IStr, LazyVal>) -> Self {
+	pub fn extend_bound(self, new_bindings: GcHashMap<IStr, Thunk<Val>>) -> Self {
 		let new_this = self.0.this.clone();
 		let new_super_obj = self.0.super_obj.clone();
 		self.extend(new_bindings, None, new_this, new_super_obj)

--- a/crates/jrsonnet-evaluator/src/dynamic.rs
+++ b/crates/jrsonnet-evaluator/src/dynamic.rs
@@ -3,8 +3,8 @@
 use gcmodule::{Cc, Trace};
 
 #[derive(Clone, Trace)]
-pub struct FutureWrapper<V: Trace + 'static>(pub Cc<RefCell<Option<V>>>);
-impl<T: Trace + 'static> FutureWrapper<T> {
+pub struct Pending<V: Trace + 'static>(pub Cc<RefCell<Option<V>>>);
+impl<T: Trace + 'static> Pending<T> {
 	pub fn new() -> Self {
 		Self(Cc::new(RefCell::new(None)))
 	}
@@ -15,7 +15,7 @@
 		self.0.borrow_mut().replace(value);
 	}
 }
-impl<T: Clone + Trace + 'static> FutureWrapper<T> {
+impl<T: Clone + Trace + 'static> Pending<T> {
 	/// # Panics
 	/// If wrapper is not yet filled
 	pub fn unwrap(&self) -> T {
@@ -23,7 +23,7 @@
 	}
 }
 
-impl<T: Trace + 'static> Default for FutureWrapper<T> {
+impl<T: Trace + 'static> Default for Pending<T> {
 	fn default() -> Self {
 		Self::new()
 	}

--- a/crates/jrsonnet-evaluator/src/error.rs
+++ b/crates/jrsonnet-evaluator/src/error.rs
@@ -45,6 +45,9 @@
 
 	#[error("variable is not defined: {0}")]
 	VariableIsNotDefined(IStr),
+	#[error("duplicate local var: {0}")]
+	DuplicateLocalVar(IStr),
+
 	#[error("type mismatch: expected {}, got {2} {0}", .1.iter().map(|e| format!("{}", e)).collect::<Vec<_>>().join(", "))]
 	TypeMismatch(&'static str, Vec<ValType>, ValType),
 	#[error("no such field: {0}")]

1use gcmodule::{Cc, Trace};1use gcmodule::{Cc, Trace};
2use jrsonnet_interner::IStr;2use jrsonnet_interner::IStr;
3use jrsonnet_parser::{3use jrsonnet_parser::{
4	ArgsDesc, AssertStmt, BindSpec, CompSpec, Expr, FieldMember, ForSpecData, IfSpecData,4	ArgsDesc, AssertStmt, BindSpec, CompSpec, Destruct, Expr, FieldMember, ForSpecData, IfSpecData,
5	LiteralType, LocExpr, Member, ObjBody, ParamsDesc,5	LiteralType, LocExpr, Member, ObjBody, ParamsDesc,
6};6};
7use jrsonnet_types::ValType;7use jrsonnet_types::ValType;
88
9use crate::{9use crate::{
10	destructure::evaluate_dest,
10	error::Error::*,11	error::Error::*,
11	evaluate::operator::{evaluate_add_op, evaluate_binary_op_special, evaluate_unary_op},12	evaluate::operator::{evaluate_add_op, evaluate_binary_op_special, evaluate_unary_op},
12	function::{CallLocation, FuncDesc, FuncVal},13	function::{CallLocation, FuncDesc, FuncVal},
13	gc::TraceBox,
14	stdlib::{std_slice, BUILTINS},14	stdlib::{std_slice, BUILTINS},
15	throw,15	tb, throw,
16	typed::Typed,16	typed::Typed,
17	val::{ArrValue, LazyValValue},17	val::{ArrValue, Thunk, ThunkValue},
18	Bindable, Context, ContextCreator, FutureWrapper, GcHashMap, LazyBinding, LazyVal, ObjValue,18	Bindable, Context, ContextCreator, GcHashMap, LazyBinding, ObjValue, ObjValueBuilder,
19	ObjValueBuilder, ObjectAssertion, Result, State, Val,19	ObjectAssertion, Pending, Result, State, Val,
20};20};
21pub mod operator;21pub mod destructure;
22
23pub fn evaluate_binding_in_future(b: &BindSpec, fctx: FutureWrapper<Context>) -> LazyVal {22pub mod operator;
24	let b = b.clone();
25	if let Some(params) = &b.params {
26		#[derive(Trace)]
27		struct LazyMethodBinding {
28			fctx: FutureWrapper<Context>,
29			name: IStr,
30			params: ParamsDesc,
31			value: LocExpr,
32		}
33		impl LazyValValue for LazyMethodBinding {
34			fn get(self: Box<Self>, _: State) -> Result<Val> {
35				Ok(evaluate_method(
36					self.fctx.unwrap(),
37					self.name,
38					self.params,
39					self.value,
40				))
41			}
42		}
43
44		let params = params.clone();
45
46		LazyVal::new(TraceBox(Box::new(LazyMethodBinding {
47			fctx,
48			name: b.name.clone(),
49			params,
50			value: b.value.clone(),
51		})))
52	} else {
53		#[derive(Trace)]
54		struct LazyNamedBinding {
55			fctx: FutureWrapper<Context>,
56			name: IStr,
57			value: LocExpr,
58		}
59		impl LazyValValue for LazyNamedBinding {
60			fn get(self: Box<Self>, s: State) -> Result<Val> {
61				evaluate_named(s, self.fctx.unwrap(), &self.value, self.name)
62			}
63		}
64		LazyVal::new(TraceBox(Box::new(LazyNamedBinding {
65			fctx,
66			name: b.name.clone(),
67			value: b.value,
68		})))
69	}
70}
7123
72#[allow(clippy::too_many_lines)]24#[allow(clippy::too_many_lines)]
73pub fn evaluate_binding(b: &BindSpec, cctx: ContextCreator) -> (IStr, LazyBinding) {25pub fn evaluate_binding(b: BindSpec, cctx: ContextCreator) -> Result<(IStr, LazyBinding)> {
74	let b = b.clone();26	match b {
27		BindSpec::Field {
75	if let Some(params) = &b.params {28			into: Destruct::Full(name),
29			value,
30		} => {
76		#[derive(Trace)]31			#[derive(Trace)]
77		struct BindableMethodLazyVal {32			struct BindableNamedThunk {
78			this: Option<ObjValue>,33				this: Option<ObjValue>,
79			super_obj: Option<ObjValue>,34				super_obj: Option<ObjValue>,
8035
81			cctx: ContextCreator,36				cctx: ContextCreator,
82			name: IStr,37				name: IStr,
83			params: ParamsDesc,
84			value: LocExpr,38				value: LocExpr,
85		}39			}
86		impl LazyValValue for BindableMethodLazyVal {40			impl ThunkValue for BindableNamedThunk {
41				type Output = Val;
87			fn get(self: Box<Self>, s: State) -> Result<Val> {42				fn get(self: Box<Self>, s: State) -> Result<Val> {
88				Ok(evaluate_method(43					evaluate_named(
44						s.clone(),
89					self.cctx.create(s, self.this, self.super_obj)?,45						self.cctx.create(s, self.this, self.super_obj)?,
90					self.name,46						&self.value,
91					self.params,47						self.name,
92					self.value,
93				))48					)
94			}49				}
95		}50			}
9651
97		#[derive(Trace)]52			#[derive(Trace)]
98		struct BindableMethod {53			struct BindableNamed {
99			cctx: ContextCreator,54				cctx: ContextCreator,
100			name: IStr,55				name: IStr,
101			params: ParamsDesc,
102			value: LocExpr,56				value: LocExpr,
103		}57			}
104		impl Bindable for BindableMethod {58			impl Bindable for BindableNamed {
105			fn bind(59				fn bind(
106				&self,60					&self,
107				_: State,61					_: State,
108				this: Option<ObjValue>,62					this: Option<ObjValue>,
109				super_obj: Option<ObjValue>,63					super_obj: Option<ObjValue>,
110			) -> Result<LazyVal> {64				) -> Result<Thunk<Val>> {
111				Ok(LazyVal::new(TraceBox(Box::new(BindableMethodLazyVal {65					Ok(Thunk::new(tb!(BindableNamedThunk {
112					this,66						this,
113					super_obj,67						super_obj,
11468
115					cctx: self.cctx.clone(),69						cctx: self.cctx.clone(),
116					name: self.name.clone(),70						name: self.name.clone(),
117					params: self.params.clone(),
118					value: self.value.clone(),71						value: self.value.clone(),
119				}))))72					})))
120			}73				}
121		}74			}
122
123		let params = params.clone();
12475
125		(76			Ok((
126			b.name.clone(),77				name.clone(),
127			LazyBinding::Bindable(Cc::new(TraceBox(Box::new(BindableMethod {78				LazyBinding::Bindable(Cc::new(tb!(BindableNamed {
128				cctx,79					cctx,
129				name: b.name.clone(),80					name: name.clone(),
130				params,
131				value: b.value.clone(),81					value: value.clone(),
132			})))),82				}))),
133		)83			))
134	} else {84		}
85		#[cfg(feature = "exp-destruct")]
86		BindSpec::Field { into: _, .. } => {
87			use crate::throw_runtime;
88			throw_runtime!("destructuring is not yet supported here")
89		}
90		BindSpec::Function {
91			name,
92			params,
93			value,
94		} => {
135		#[derive(Trace)]95			#[derive(Trace)]
136		struct BindableNamedLazyVal {96			struct BindableMethodThunk {
137			this: Option<ObjValue>,97				this: Option<ObjValue>,
138			super_obj: Option<ObjValue>,98				super_obj: Option<ObjValue>,
13999
140			cctx: ContextCreator,100				cctx: ContextCreator,
141			name: IStr,101				name: IStr,
102				params: ParamsDesc,
142			value: LocExpr,103				value: LocExpr,
143		}104			}
144		impl LazyValValue for BindableNamedLazyVal {105			impl ThunkValue for BindableMethodThunk {
106				type Output = Val;
145			fn get(self: Box<Self>, s: State) -> Result<Val> {107				fn get(self: Box<Self>, s: State) -> Result<Val> {
146				evaluate_named(108					Ok(evaluate_method(
147					s.clone(),
148					self.cctx.create(s, self.this, self.super_obj)?,109						self.cctx.create(s, self.this, self.super_obj)?,
149					&self.value,110						self.name,
150					self.name,111						self.params,
112						self.value,
151				)113					))
152			}114				}
153		}115			}
154116
155		#[derive(Trace)]117			#[derive(Trace)]
156		struct BindableNamed {118			struct BindableMethod {
157			cctx: ContextCreator,119				cctx: ContextCreator,
158			name: IStr,120				name: IStr,
121				params: ParamsDesc,
159			value: LocExpr,122				value: LocExpr,
160		}123			}
161		impl Bindable for BindableNamed {124			impl Bindable for BindableMethod {
162			fn bind(125				fn bind(
163				&self,126					&self,
164				_: State,127					_: State,
165				this: Option<ObjValue>,128					this: Option<ObjValue>,
166				super_obj: Option<ObjValue>,129					super_obj: Option<ObjValue>,
167			) -> Result<LazyVal> {130				) -> Result<Thunk<Val>> {
168				Ok(LazyVal::new(TraceBox(Box::new(BindableNamedLazyVal {131					Ok(Thunk::<Val>::new(tb!(BindableMethodThunk {
169					this,132						this,
170					super_obj,133						super_obj,
171134
172					cctx: self.cctx.clone(),135						cctx: self.cctx.clone(),
173					name: self.name.clone(),136						name: self.name.clone(),
137						params: self.params.clone(),
174					value: self.value.clone(),138						value: self.value.clone(),
175				}))))139					})))
176			}140				}
177		}141			}
142
143			let params = params.clone();
178144
179		(145			Ok((
180			b.name.clone(),146				name.clone(),
181			LazyBinding::Bindable(Cc::new(TraceBox(Box::new(BindableNamed {147				LazyBinding::Bindable(Cc::new(tb!(BindableMethod {
182				cctx,148					cctx,
183				name: b.name.clone(),149					name: name.clone(),
150					params,
184				value: b.value.clone(),151					value,
185			})))),152				}))),
186		)153			))
187	}154		}
155	}
188}156}
189157
190pub fn evaluate_method(ctx: Context, name: IStr, params: ParamsDesc, body: LocExpr) -> Val {158pub fn evaluate_method(ctx: Context, name: IStr, params: ParamsDesc, body: LocExpr) -> Val {
252220
253#[allow(clippy::too_many_lines)]221#[allow(clippy::too_many_lines)]
254pub fn evaluate_member_list_object(s: State, ctx: Context, members: &[Member]) -> Result<ObjValue> {222pub fn evaluate_member_list_object(s: State, ctx: Context, members: &[Member]) -> Result<ObjValue> {
255	let new_bindings = FutureWrapper::new();223	let new_bindings = Pending::new();
256	let future_this = FutureWrapper::new();224	let future_this = Pending::new();
257	let cctx = ContextCreator(ctx.clone(), new_bindings.clone());225	let cctx = ContextCreator(ctx.clone(), new_bindings.clone());
258	{226	{
259		let mut bindings: GcHashMap<IStr, LazyBinding> = GcHashMap::with_capacity(members.len());227		let mut bindings: GcHashMap<IStr, LazyBinding> = GcHashMap::with_capacity(members.len());
260		for (n, b) in members228		for r in members
261			.iter()229			.iter()
262			.filter_map(|m| match m {230			.filter_map(|m| match m {
263				Member::BindStmt(b) => Some(b.clone()),231				Member::BindStmt(b) => Some(b.clone()),
264				_ => None,232				_ => None,
265			})233			})
266			.map(|b| evaluate_binding(&b, cctx.clone()))234			.map(|b| evaluate_binding(b.clone(), cctx.clone()))
267		{235		{
236			let (n, b) = r?;
268			bindings.insert(n, b);237			bindings.insert(n, b);
269		}238		}
270		new_bindings.fill(bindings);239		new_bindings.fill(bindings);
292						s: State,261						s: State,
293						this: Option<ObjValue>,262						this: Option<ObjValue>,
294						super_obj: Option<ObjValue>,263						super_obj: Option<ObjValue>,
295					) -> Result<LazyVal> {264					) -> Result<Thunk<Val>> {
296						Ok(LazyVal::new_resolved(evaluate_named(265						Ok(Thunk::evaluated(evaluate_named(
297							s.clone(),266							s.clone(),
298							self.cctx.create(s, this, super_obj)?,267							self.cctx.create(s, this, super_obj)?,
299							&self.value,268							&self.value,
316					.with_location(value.1.clone())285					.with_location(value.1.clone())
317					.bindable(286					.bindable(
318						s.clone(),287						s.clone(),
319						TraceBox(Box::new(ObjMemberBinding {288						tb!(ObjMemberBinding {
320							cctx: cctx.clone(),289							cctx: cctx.clone(),
321							value: value.clone(),290							value: value.clone(),
322							name,291							name,
323						})),292						}),
324					)?;293					)?;
325			}294			}
326			Member::Field(FieldMember {295			Member::Field(FieldMember {
342						s: State,311						s: State,
343						this: Option<ObjValue>,312						this: Option<ObjValue>,
344						super_obj: Option<ObjValue>,313						super_obj: Option<ObjValue>,
345					) -> Result<LazyVal> {314					) -> Result<Thunk<Val>> {
346						Ok(LazyVal::new_resolved(evaluate_method(315						Ok(Thunk::evaluated(evaluate_method(
347							self.cctx.create(s, this, super_obj)?,316							self.cctx.create(s, this, super_obj)?,
348							self.name.clone(),317							self.name.clone(),
349							self.params.clone(),318							self.params.clone(),
364					.with_location(value.1.clone())333					.with_location(value.1.clone())
365					.bindable(334					.bindable(
366						s.clone(),335						s.clone(),
367						TraceBox(Box::new(ObjMemberBinding {336						tb!(ObjMemberBinding {
368							cctx: cctx.clone(),337							cctx: cctx.clone(),
369							value: value.clone(),338							value: value.clone(),
370							params: params.clone(),339							params: params.clone(),
371							name,340							name,
372						})),341						}),
373					)?;342					)?;
374			}343			}
375			Member::BindStmt(_) => {}344			Member::BindStmt(_) => {}
390						evaluate_assert(s, ctx, &self.assert)359						evaluate_assert(s, ctx, &self.assert)
391					}360					}
392				}361				}
393				builder.assert(TraceBox(Box::new(ObjectAssert {362				builder.assert(tb!(ObjectAssert {
394					cctx: cctx.clone(),363					cctx: cctx.clone(),
395					assert: stmt.clone(),364					assert: stmt.clone(),
396				})));365				}));
397			}366			}
398		}367		}
399	}368	}
406	Ok(match object {375	Ok(match object {
407		ObjBody::MemberList(members) => evaluate_member_list_object(s, ctx, members)?,376		ObjBody::MemberList(members) => evaluate_member_list_object(s, ctx, members)?,
408		ObjBody::ObjComp(obj) => {377		ObjBody::ObjComp(obj) => {
409			let future_this = FutureWrapper::new();378			let future_this = Pending::new();
410			let mut builder = ObjValueBuilder::new();379			let mut builder = ObjValueBuilder::new();
411			evaluate_comp(s.clone(), ctx, &obj.compspecs, &mut |ctx| {380			evaluate_comp(s.clone(), ctx, &obj.compspecs, &mut |ctx| {
412				let new_bindings = FutureWrapper::new();381				let new_bindings = Pending::new();
413				let cctx = ContextCreator(ctx.clone(), new_bindings.clone());382				let cctx = ContextCreator(ctx.clone(), new_bindings.clone());
414				let mut bindings: GcHashMap<IStr, LazyBinding> =383				let mut bindings: GcHashMap<IStr, LazyBinding> =
415					GcHashMap::with_capacity(obj.pre_locals.len() + obj.post_locals.len());384					GcHashMap::with_capacity(obj.pre_locals.len() + obj.post_locals.len());
416				for (n, b) in obj385				for r in obj
417					.pre_locals386					.pre_locals
418					.iter()387					.iter()
419					.chain(obj.post_locals.iter())388					.chain(obj.post_locals.iter())
420					.map(|b| evaluate_binding(b, cctx.clone()))389					.map(|b| evaluate_binding(b.clone(), cctx.clone()))
421				{390				{
391					let (n, b) = r?;
422					bindings.insert(n, b);392					bindings.insert(n, b);
423				}393				}
424				new_bindings.fill(bindings.clone());394				new_bindings.fill(bindings.clone());
439								s: State,409								s: State,
440								this: Option<ObjValue>,410								this: Option<ObjValue>,
441								_super_obj: Option<ObjValue>,411								_super_obj: Option<ObjValue>,
442							) -> Result<LazyVal> {412							) -> Result<Thunk<Val>> {
443								Ok(LazyVal::new_resolved(evaluate(413								Ok(Thunk::evaluated(evaluate(
444									s,414									s,
445									self.ctx.clone().extend(GcHashMap::new(), None, this, None),415									self.ctx.clone().extend(GcHashMap::new(), None, this, None),
446									&self.value,416									&self.value,
453							.with_add(obj.plus)423							.with_add(obj.plus)
454							.bindable(424							.bindable(
455								s.clone(),425								s.clone(),
456								TraceBox(Box::new(ObjCompBinding {426								tb!(ObjCompBinding {
457									ctx,427									ctx,
458									value: obj.value.clone(),428									value: obj.value.clone(),
459								})),429								}),
460							)?;430							)?;
461					}431					}
462					v => throw!(FieldMustBeStringGot(v.value_type())),432					v => throw!(FieldMustBeStringGot(v.value_type())),
620			}590			}
621		}591		}
622		LocalExpr(bindings, returned) => {592		LocalExpr(bindings, returned) => {
623			let mut new_bindings: GcHashMap<IStr, LazyVal> =593			let mut new_bindings: GcHashMap<IStr, Thunk<Val>> =
624				GcHashMap::with_capacity(bindings.len());594				GcHashMap::with_capacity(bindings.len());
625			let fctx = Context::new_future();595			let fctx = Context::new_future();
626			for b in bindings {596			for b in bindings {
627				new_bindings.insert(b.name.clone(), evaluate_binding_in_future(b, fctx.clone()));597				evaluate_dest(b, fctx.clone(), &mut new_bindings)?;
628			}598			}
629			let ctx = ctx.extend_bound(new_bindings).into_future(fctx);599			let ctx = ctx.extend_bound(new_bindings).into_future(fctx);
630			evaluate(s, ctx, &returned.clone())?600			evaluate(s, ctx, &returned.clone())?
638					ctx: Context,608					ctx: Context,
639					item: LocExpr,609					item: LocExpr,
640				}610				}
641				impl LazyValValue for ArrayElement {611				impl ThunkValue for ArrayElement {
612					type Output = Val;
642					fn get(self: Box<Self>, s: State) -> Result<Val> {613					fn get(self: Box<Self>, s: State) -> Result<Val> {
643						evaluate(s, self.ctx, &self.item)614						evaluate(s, self.ctx, &self.item)
644					}615					}
645				}616				}
646				out.push(LazyVal::new(TraceBox(Box::new(ArrayElement {617				out.push(Thunk::new(tb!(ArrayElement {
647					ctx: ctx.clone(),618					ctx: ctx.clone(),
648					item: item.clone(),619					item: item.clone(),
649				}))));620				})));
650			}621			}
651			Val::Arr(out.into())622			Val::Arr(out.into())
652		}623		}

--- a/crates/jrsonnet-evaluator/src/function/arglike.rs
+++ b/crates/jrsonnet-evaluator/src/function/arglike.rs
@@ -5,34 +5,34 @@
 use jrsonnet_parser::{ArgsDesc, LocExpr};
 
 use crate::{
-	error::Result, evaluate, gc::TraceBox, typed::Typed, val::LazyValValue, Context, LazyVal,
-	State, Val,
+	error::Result, evaluate, tb, typed::Typed, val::ThunkValue, Context, State, Thunk, Val,
 };
 
 #[derive(Trace)]
-struct EvaluateLazyVal {
+struct EvaluateThunk {
 	ctx: Context,
 	expr: LocExpr,
 }
-impl LazyValValue for EvaluateLazyVal {
+impl ThunkValue for EvaluateThunk {
+	type Output = Val;
 	fn get(self: Box<Self>, s: State) -> Result<Val> {
 		evaluate(s, self.ctx, &self.expr)
 	}
 }
 
 pub trait ArgLike {
-	fn evaluate_arg(&self, s: State, ctx: Context, tailstrict: bool) -> Result<LazyVal>;
+	fn evaluate_arg(&self, s: State, ctx: Context, tailstrict: bool) -> Result<Thunk<Val>>;
 }
 
 impl ArgLike for &LocExpr {
-	fn evaluate_arg(&self, s: State, ctx: Context, tailstrict: bool) -> Result<LazyVal> {
+	fn evaluate_arg(&self, s: State, ctx: Context, tailstrict: bool) -> Result<Thunk<Val>> {
 		Ok(if tailstrict {
-			LazyVal::new_resolved(evaluate(s, ctx, self)?)
+			Thunk::evaluated(evaluate(s, ctx, self)?)
 		} else {
-			LazyVal::new(TraceBox(Box::new(EvaluateLazyVal {
+			Thunk::new(tb!(EvaluateThunk {
 				ctx,
 				expr: (*self).clone(),
-			})))
+			}))
 		})
 	}
 }
@@ -41,9 +41,9 @@
 where
 	T: Typed + Clone,
 {
-	fn evaluate_arg(&self, s: State, _ctx: Context, _tailstrict: bool) -> Result<LazyVal> {
+	fn evaluate_arg(&self, s: State, _ctx: Context, _tailstrict: bool) -> Result<Thunk<Val>> {
 		let val = T::into_untyped(self.clone(), s)?;
-		Ok(LazyVal::new_resolved(val))
+		Ok(Thunk::evaluated(val))
 	}
 }
 
@@ -53,18 +53,18 @@
 	Val(Val),
 }
 impl ArgLike for TlaArg {
-	fn evaluate_arg(&self, s: State, ctx: Context, tailstrict: bool) -> Result<LazyVal> {
+	fn evaluate_arg(&self, s: State, ctx: Context, tailstrict: bool) -> Result<Thunk<Val>> {
 		match self {
-			TlaArg::String(s) => Ok(LazyVal::new_resolved(Val::Str(s.clone()))),
+			TlaArg::String(s) => Ok(Thunk::evaluated(Val::Str(s.clone()))),
 			TlaArg::Code(code) => Ok(if tailstrict {
-				LazyVal::new_resolved(evaluate(s, ctx, code)?)
+				Thunk::evaluated(evaluate(s, ctx, code)?)
 			} else {
-				LazyVal::new(TraceBox(Box::new(EvaluateLazyVal {
+				Thunk::new(tb!(EvaluateThunk {
 					ctx,
 					expr: code.clone(),
-				})))
+				}))
 			}),
-			TlaArg::Val(val) => Ok(LazyVal::new_resolved(val.clone())),
+			TlaArg::Val(val) => Ok(Thunk::evaluated(val.clone())),
 		}
 	}
 }
@@ -83,14 +83,14 @@
 		s: State,
 		ctx: Context,
 		tailstrict: bool,
-		handler: &mut dyn FnMut(usize, LazyVal) -> Result<()>,
+		handler: &mut dyn FnMut(usize, Thunk<Val>) -> Result<()>,
 	) -> Result<()>;
 	fn named_iter(
 		&self,
 		s: State,
 		ctx: Context,
 		tailstrict: bool,
-		handler: &mut dyn FnMut(&IStr, LazyVal) -> Result<()>,
+		handler: &mut dyn FnMut(&IStr, Thunk<Val>) -> Result<()>,
 	) -> Result<()>;
 	fn named_names(&self, handler: &mut dyn FnMut(&IStr));
 }
@@ -105,18 +105,18 @@
 		s: State,
 		ctx: Context,
 		tailstrict: bool,
-		handler: &mut dyn FnMut(usize, LazyVal) -> Result<()>,
+		handler: &mut dyn FnMut(usize, Thunk<Val>) -> Result<()>,
 	) -> Result<()> {
 		for (id, arg) in self.unnamed.iter().enumerate() {
 			handler(
 				id,
 				if tailstrict {
-					LazyVal::new_resolved(evaluate(s.clone(), ctx.clone(), arg)?)
+					Thunk::evaluated(evaluate(s.clone(), ctx.clone(), arg)?)
 				} else {
-					LazyVal::new(TraceBox(Box::new(EvaluateLazyVal {
+					Thunk::new(tb!(EvaluateThunk {
 						ctx: ctx.clone(),
 						expr: arg.clone(),
-					})))
+					}))
 				},
 			)?;
 		}
@@ -128,18 +128,18 @@
 		s: State,
 		ctx: Context,
 		tailstrict: bool,
-		handler: &mut dyn FnMut(&IStr, LazyVal) -> Result<()>,
+		handler: &mut dyn FnMut(&IStr, Thunk<Val>) -> Result<()>,
 	) -> Result<()> {
 		for (name, arg) in &self.named {
 			handler(
 				name,
 				if tailstrict {
-					LazyVal::new_resolved(evaluate(s.clone(), ctx.clone(), arg)?)
+					Thunk::evaluated(evaluate(s.clone(), ctx.clone(), arg)?)
 				} else {
-					LazyVal::new(TraceBox(Box::new(EvaluateLazyVal {
+					Thunk::new(tb!(EvaluateThunk {
 						ctx: ctx.clone(),
 						expr: arg.clone(),
-					})))
+					}))
 				},
 			)?;
 		}
@@ -164,7 +164,7 @@
 		_s: State,
 		_ctx: Context,
 		_tailstrict: bool,
-		_handler: &mut dyn FnMut(usize, LazyVal) -> Result<()>,
+		_handler: &mut dyn FnMut(usize, Thunk<Val>) -> Result<()>,
 	) -> Result<()> {
 		Ok(())
 	}
@@ -174,7 +174,7 @@
 		s: State,
 		ctx: Context,
 		tailstrict: bool,
-		handler: &mut dyn FnMut(&IStr, LazyVal) -> Result<()>,
+		handler: &mut dyn FnMut(&IStr, Thunk<Val>) -> Result<()>,
 	) -> Result<()> {
 		for (name, value) in self.iter() {
 			handler(
@@ -205,7 +205,7 @@
 				s: State,
 				ctx: Context,
 				tailstrict: bool,
-				handler: &mut dyn FnMut(usize, LazyVal) -> Result<()>,
+				handler: &mut dyn FnMut(usize, Thunk<Val>) -> Result<()>,
 			) -> Result<()> {
 				let mut i = 0usize;
 				let ($($gen,)*) = self;
@@ -220,7 +220,7 @@
 				_s: State,
 				_ctx: Context,
 				_tailstrict: bool,
-				_handler: &mut dyn FnMut(&IStr, LazyVal) -> Result<()>,
+				_handler: &mut dyn FnMut(&IStr, Thunk<Val>) -> Result<()>,
 			) -> Result<()> {
 				Ok(())
 			}
@@ -236,7 +236,7 @@
 				_s: State,
 				_ctx: Context,
 				_tailstrict: bool,
-				_handler: &mut dyn FnMut(usize, LazyVal) -> Result<()>,
+				_handler: &mut dyn FnMut(usize, Thunk<Val>) -> Result<()>,
 			) -> Result<()> {
 				Ok(())
 			}
@@ -246,7 +246,7 @@
 				s: State,
 				ctx: Context,
 				tailstrict: bool,
-				handler: &mut dyn FnMut(&IStr, LazyVal) -> Result<()>,
+				handler: &mut dyn FnMut(&IStr, Thunk<Val>) -> Result<()>,
 			) -> Result<()> {
 				let ($($gen,)*) = self;
 				$(
@@ -285,7 +285,7 @@
 		_s: State,
 		_ctx: Context,
 		_tailstrict: bool,
-		_handler: &mut dyn FnMut(usize, LazyVal) -> Result<()>,
+		_handler: &mut dyn FnMut(usize, Thunk<Val>) -> Result<()>,
 	) -> Result<()> {
 		Ok(())
 	}
@@ -295,7 +295,7 @@
 		_s: State,
 		_ctx: Context,
 		_tailstrict: bool,
-		_handler: &mut dyn FnMut(&IStr, LazyVal) -> Result<()>,
+		_handler: &mut dyn FnMut(&IStr, Thunk<Val>) -> Result<()>,
 	) -> Result<()> {
 		Ok(())
 	}

--- a/crates/jrsonnet-evaluator/src/function/parse.rs
+++ b/crates/jrsonnet-evaluator/src/function/parse.rs
@@ -9,20 +9,21 @@
 use crate::{
 	error::{Error::*, Result},
 	evaluate_named,
-	gc::{GcHashMap, TraceBox},
-	throw,
-	val::LazyValValue,
-	Context, FutureWrapper, LazyVal, State, Val,
+	gc::GcHashMap,
+	tb, throw,
+	val::ThunkValue,
+	Context, Pending, State, Thunk, Val,
 };
 
 #[derive(Trace)]
-struct EvaluateNamedLazyVal {
-	ctx: FutureWrapper<Context>,
+struct EvaluateNamedThunk {
+	ctx: Pending<Context>,
 	name: IStr,
 	value: LocExpr,
 }
 
-impl LazyValValue for EvaluateNamedLazyVal {
+impl ThunkValue for EvaluateNamedThunk {
+	type Output = Val;
 	fn get(self: Box<Self>, s: State) -> Result<Val> {
 		evaluate_named(s, self.ctx.unwrap(), &self.value, self.name)
 	}
@@ -83,11 +84,11 @@
 
 			defaults.insert(
 				param.0.clone(),
-				LazyVal::new(TraceBox(Box::new(EvaluateNamedLazyVal {
+				Thunk::new(tb!(EvaluateNamedThunk {
 					ctx: fctx.clone(),
 					name: param.0.clone(),
 					value: param.1.clone().expect("default exists"),
-				}))),
+				})),
 			);
 			filled_args += 1;
 		}
@@ -131,7 +132,7 @@
 	params: &[BuiltinParam],
 	args: &dyn ArgsLike,
 	tailstrict: bool,
-) -> Result<GcHashMap<BuiltinParamName, LazyVal>> {
+) -> Result<GcHashMap<BuiltinParamName, Thunk<Val>>> {
 	let mut passed_args = GcHashMap::with_capacity(params.len());
 	if args.unnamed_len() > params.len() {
 		throw!(TooManyArgsFunctionHas(params.len()))
@@ -191,7 +192,8 @@
 pub fn parse_default_function_call(body_ctx: Context, params: &ParamsDesc) -> Context {
 	#[derive(Trace)]
 	struct DependsOnUnbound(IStr);
-	impl LazyValValue for DependsOnUnbound {
+	impl ThunkValue for DependsOnUnbound {
+		type Output = Val;
 		fn get(self: Box<Self>, _: State) -> Result<Val> {
 			Err(FunctionParameterNotBoundInCall(self.0.clone()).into())
 		}
@@ -205,16 +207,16 @@
 		if let Some(v) = &param.1 {
 			bindings.insert(
 				param.0.clone(),
-				LazyVal::new(TraceBox(Box::new(EvaluateNamedLazyVal {
+				Thunk::new(tb!(EvaluateNamedThunk {
 					ctx: fctx.clone(),
 					name: param.0.clone(),
 					value: v.clone(),
-				}))),
+				})),
 			);
 		} else {
 			bindings.insert(
 				param.0.clone(),
-				LazyVal::new(TraceBox(Box::new(DependsOnUnbound(param.0.clone())))),
+				Thunk::new(tb!(DependsOnUnbound(param.0.clone()))),
 			);
 		}
 	}

--- a/crates/jrsonnet-evaluator/src/gc.rs
+++ b/crates/jrsonnet-evaluator/src/gc.rs
@@ -10,8 +10,15 @@
 use rustc_hash::{FxHashMap, FxHashSet};
 
 /// Replacement for box, which assumes that the underlying type is [`Trace`]
+/// Used in places, where Cc<dyn Trait> should be used instead, but it can't, because CoerceUnsiced is not stable
 #[derive(Debug, Clone)]
 pub struct TraceBox<T: ?Sized>(pub Box<T>);
+#[macro_export]
+macro_rules! tb {
+	($v:expr) => {
+		$crate::gc::TraceBox(Box::new($v))
+	};
+}
 
 impl<T: ?Sized + Trace> Trace for TraceBox<T> {
 	fn trace(&self, tracer: &mut Tracer) {

--- a/crates/jrsonnet-evaluator/src/lib.rs
+++ b/crates/jrsonnet-evaluator/src/lib.rs
@@ -58,7 +58,7 @@
 use jrsonnet_parser::*;
 pub use obj::*;
 use trace::{location_to_offset, offset_to_location, CodeLocation, CompactFormat, TraceFormat};
-pub use val::{LazyVal, ManifestFormat, Val};
+pub use val::{ManifestFormat, Thunk, Val};
 
 pub trait Bindable: Trace + 'static {
 	fn bind(
@@ -66,13 +66,13 @@
 		s: State,
 		this: Option<ObjValue>,
 		super_obj: Option<ObjValue>,
-	) -> Result<LazyVal>;
+	) -> Result<Thunk<Val>>;
 }
 
 #[derive(Clone, Trace)]
 pub enum LazyBinding {
 	Bindable(Cc<TraceBox<dyn Bindable>>),
-	Bound(LazyVal),
+	Bound(Thunk<Val>),
 }
 
 impl Debug for LazyBinding {
@@ -86,7 +86,7 @@
 		s: State,
 		this: Option<ObjValue>,
 		super_obj: Option<ObjValue>,
-	) -> Result<LazyVal> {
+	) -> Result<Thunk<Val>> {
 		match self {
 			Self::Bindable(v) => v.bind(s, this, super_obj),
 			Self::Bound(v) => Ok(v.clone()),
@@ -343,7 +343,7 @@
 		let globals = &self.settings().globals;
 		let mut new_bindings = GcHashMap::with_capacity(globals.len());
 		for (name, value) in globals.iter() {
-			new_bindings.insert(name.clone(), LazyVal::new_resolved(value.clone()));
+			new_bindings.insert(name.clone(), Thunk::evaluated(value.clone()));
 		}
 		Context::new().extend_bound(new_bindings)
 	}

--- a/crates/jrsonnet-evaluator/src/map.rs
+++ b/crates/jrsonnet-evaluator/src/map.rs
@@ -1,27 +1,27 @@
 use gcmodule::{Cc, Trace};
 use jrsonnet_interner::IStr;
 
-use crate::{GcHashMap, LazyVal};
+use crate::{GcHashMap, Thunk, Val};
 
 #[derive(Trace)]
 #[force_tracking]
 pub struct LayeredHashMapInternals {
 	parent: Option<LayeredHashMap>,
-	current: GcHashMap<IStr, LazyVal>,
+	current: GcHashMap<IStr, Thunk<Val>>,
 }
 
 #[derive(Trace)]
 pub struct LayeredHashMap(Cc<LayeredHashMapInternals>);
 
 impl LayeredHashMap {
-	pub fn extend(self, new_layer: GcHashMap<IStr, LazyVal>) -> Self {
+	pub fn extend(self, new_layer: GcHashMap<IStr, Thunk<Val>>) -> Self {
 		Self(Cc::new(LayeredHashMapInternals {
 			parent: Some(self),
 			current: new_layer,
 		}))
 	}
 
-	pub fn get(&self, key: &IStr) -> Option<&LazyVal> {
+	pub fn get(&self, key: &IStr) -> Option<&Thunk<Val>> {
 		(self.0)
 			.current
 			.get(key)

--- a/crates/jrsonnet-evaluator/src/obj.rs
+++ b/crates/jrsonnet-evaluator/src/obj.rs
@@ -16,7 +16,7 @@
 	function::CallLocation,
 	gc::{GcHashMap, GcHashSet, TraceBox},
 	operator::evaluate_add_op,
-	throw, weak_ptr_eq, weak_raw, Bindable, LazyBinding, LazyVal, Result, State, Val,
+	throw, weak_ptr_eq, weak_raw, Bindable, LazyBinding, Result, State, Thunk, Val,
 };
 
 #[cfg(not(feature = "exp-preserve-order"))]
@@ -581,7 +581,7 @@
 pub struct ValueBuilder<'v>(&'v mut ObjValueBuilder);
 impl<'v> ObjMemberBuilder<ValueBuilder<'v>> {
 	pub fn value(self, s: State, value: Val) -> Result<()> {
-		self.binding(s, LazyBinding::Bound(LazyVal::new_resolved(value)))
+		self.binding(s, LazyBinding::Bound(Thunk::evaluated(value)))
 	}
 	pub fn bindable(self, s: State, bindable: TraceBox<dyn Bindable>) -> Result<()> {
 		self.binding(s, LazyBinding::Bindable(Cc::new(bindable)))
@@ -604,7 +604,7 @@
 pub struct ExtendBuilder<'v>(&'v mut ObjValue);
 impl<'v> ObjMemberBuilder<ExtendBuilder<'v>> {
 	pub fn value(self, value: Val) {
-		self.binding(LazyBinding::Bound(LazyVal::new_resolved(value)));
+		self.binding(LazyBinding::Bound(Thunk::evaluated(value)));
 	}
 	pub fn bindable(self, bindable: TraceBox<dyn Bindable>) {
 		self.binding(LazyBinding::Bindable(Cc::new(bindable)));

--- a/crates/jrsonnet-evaluator/src/val.rs
+++ b/crates/jrsonnet-evaluator/src/val.rs
@@ -15,41 +15,45 @@
 	throw, ObjValue, Result, State,
 };
 
-pub trait LazyValValue: Trace {
-	fn get(self: Box<Self>, s: State) -> Result<Val>;
+pub trait ThunkValue: Trace {
+	type Output;
+	fn get(self: Box<Self>, s: State) -> Result<Self::Output>;
 }
 
 #[derive(Trace)]
-enum LazyValInternals {
-	Computed(Val),
+enum ThunkInner<T> {
+	Computed(T),
 	Errored(LocError),
-	Waiting(TraceBox<dyn LazyValValue>),
+	Waiting(TraceBox<dyn ThunkValue<Output = T>>),
 	Pending,
 }
 
 #[allow(clippy::module_name_repetitions)]
 #[derive(Clone, Trace)]
-pub struct LazyVal(Cc<RefCell<LazyValInternals>>);
-impl LazyVal {
-	pub fn new(f: TraceBox<dyn LazyValValue>) -> Self {
-		Self(Cc::new(RefCell::new(LazyValInternals::Waiting(f))))
+pub struct Thunk<T>(Cc<RefCell<ThunkInner<T>>>);
+impl<T> Thunk<T>
+where
+	T: Clone + Trace,
+{
+	pub fn new(f: TraceBox<dyn ThunkValue<Output = T>>) -> Self {
+		Self(Cc::new(RefCell::new(ThunkInner::Waiting(f))))
 	}
-	pub fn new_resolved(val: Val) -> Self {
-		Self(Cc::new(RefCell::new(LazyValInternals::Computed(val))))
+	pub fn evaluated(val: T) -> Self {
+		Self(Cc::new(RefCell::new(ThunkInner::Computed(val))))
 	}
 	pub fn force(&self, s: State) -> Result<()> {
 		self.evaluate(s)?;
 		Ok(())
 	}
-	pub fn evaluate(&self, s: State) -> Result<Val> {
+	pub fn evaluate(&self, s: State) -> Result<T> {
 		match &*self.0.borrow() {
-			LazyValInternals::Computed(v) => return Ok(v.clone()),
-			LazyValInternals::Errored(e) => return Err(e.clone()),
-			LazyValInternals::Pending => return Err(InfiniteRecursionDetected.into()),
-			LazyValInternals::Waiting(..) => (),
+			ThunkInner::Computed(v) => return Ok(v.clone()),
+			ThunkInner::Errored(e) => return Err(e.clone()),
+			ThunkInner::Pending => return Err(InfiniteRecursionDetected.into()),
+			ThunkInner::Waiting(..) => (),
 		};
-		let value = if let LazyValInternals::Waiting(value) =
-			std::mem::replace(&mut *self.0.borrow_mut(), LazyValInternals::Pending)
+		let value = if let ThunkInner::Waiting(value) =
+			std::mem::replace(&mut *self.0.borrow_mut(), ThunkInner::Pending)
 		{
 			value
 		} else {
@@ -58,21 +62,21 @@
 		let new_value = match value.0.get(s) {
 			Ok(v) => v,
 			Err(e) => {
-				*self.0.borrow_mut() = LazyValInternals::Errored(e.clone());
+				*self.0.borrow_mut() = ThunkInner::Errored(e.clone());
 				return Err(e);
 			}
 		};
-		*self.0.borrow_mut() = LazyValInternals::Computed(new_value.clone());
+		*self.0.borrow_mut() = ThunkInner::Computed(new_value.clone());
 		Ok(new_value)
 	}
 }
 
-impl Debug for LazyVal {
+impl<T: Debug> Debug for Thunk<T> {
 	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 		write!(f, "Lazy")
 	}
 }
-impl PartialEq for LazyVal {
+impl<T> PartialEq for Thunk<T> {
 	fn eq(&self, other: &Self) -> bool {
 		cc_ptr_eq(&self.0, &other.0)
 	}
@@ -142,7 +146,7 @@
 #[force_tracking]
 pub enum ArrValue {
 	Bytes(#[skip_trace] Rc<[u8]>),
-	Lazy(Cc<Vec<LazyVal>>),
+	Lazy(Cc<Vec<Thunk<Val>>>),
 	Eager(Cc<Vec<Val>>),
 	Extended(Box<(Self, Self)>),
 	Range(i32, i32),
@@ -240,13 +244,13 @@
 		}
 	}
 
-	pub fn get_lazy(&self, index: usize) -> Option<LazyVal> {
+	pub fn get_lazy(&self, index: usize) -> Option<Thunk<Val>> {
 		match self {
 			Self::Bytes(i) => i
 				.get(index)
-				.map(|b| LazyVal::new_resolved(Val::Num(f64::from(*b)))),
+				.map(|b| Thunk::evaluated(Val::Num(f64::from(*b)))),
 			Self::Lazy(vec) => vec.get(index).cloned(),
-			Self::Eager(vec) => vec.get(index).cloned().map(LazyVal::new_resolved),
+			Self::Eager(vec) => vec.get(index).cloned().map(Thunk::evaluated),
 			Self::Extended(v) => {
 				let a_len = v.0.len();
 				if a_len > index {
@@ -259,7 +263,7 @@
 				if index >= self.len() {
 					return None;
 				}
-				Some(LazyVal::new_resolved(Val::Num(
+				Some(Thunk::evaluated(Val::Num(
 					((*a as isize) + index as isize) as f64,
 				)))
 			}
@@ -343,11 +347,11 @@
 		})
 	}
 
-	pub fn iter_lazy(&self) -> impl DoubleEndedIterator<Item = LazyVal> + '_ {
+	pub fn iter_lazy(&self) -> impl DoubleEndedIterator<Item = Thunk<Val>> + '_ {
 		(0..self.len()).map(move |idx| match self {
-			Self::Bytes(b) => LazyVal::new_resolved(Val::Num(f64::from(b[idx]))),
+			Self::Bytes(b) => Thunk::evaluated(Val::Num(f64::from(b[idx]))),
 			Self::Lazy(l) => l[idx].clone(),
-			Self::Eager(e) => LazyVal::new_resolved(e[idx].clone()),
+			Self::Eager(e) => Thunk::evaluated(e[idx].clone()),
 			Self::Slice(..) | Self::Extended(..) | Self::Range(..) | Self::Reversed(..) => {
 				self.get_lazy(idx).expect("idx < len")
 			}
@@ -391,8 +395,8 @@
 	}
 }
 
-impl From<Vec<LazyVal>> for ArrValue {
-	fn from(v: Vec<LazyVal>) -> Self {
+impl From<Vec<Thunk<Val>>> for ArrValue {
+	fn from(v: Vec<Thunk<Val>>) -> Self {
 		Self::Lazy(Cc::new(v))
 	}
 }

--- a/crates/jrsonnet-evaluator/tests/builtin.rs
+++ b/crates/jrsonnet-evaluator/tests/builtin.rs
@@ -7,6 +7,7 @@
 	error::Result,
 	function::{builtin, builtin::Builtin, CallLocation, FuncVal},
 	gc::TraceBox,
+	tb,
 	typed::Typed,
 	State, Val,
 };
@@ -70,9 +71,7 @@
 
 #[builtin]
 fn curry_add(a: u32) -> Result<FuncVal> {
-	Ok(FuncVal::Builtin(Cc::new(TraceBox(Box::new(curried_add {
-		a,
-	})))))
+	Ok(FuncVal::Builtin(Cc::new(tb!(curried_add { a }))))
 }
 
 #[test]

--- a/crates/jrsonnet-evaluator/tests/common.rs
+++ b/crates/jrsonnet-evaluator/tests/common.rs
@@ -1,7 +1,7 @@
 use jrsonnet_evaluator::{
 	error::Result,
 	function::{builtin, FuncVal},
-	throw_runtime, LazyVal, ObjValueBuilder, State, Val,
+	throw_runtime, ObjValueBuilder, State, Thunk, Val,
 };
 
 #[macro_export]
@@ -38,7 +38,7 @@
 }
 
 #[builtin]
-fn assert_throw(s: State, lazy: LazyVal, message: String) -> Result<bool> {
+fn assert_throw(s: State, lazy: Thunk<Val>, message: String) -> Result<bool> {
 	match lazy.evaluate(s) {
 		Ok(_) => {
 			throw_runtime!("expected argument to throw on evaluation, but it returned instead")

--- a/crates/jrsonnet-macros/src/lib.rs
+++ b/crates/jrsonnet-macros/src/lib.rs
@@ -150,7 +150,7 @@
 			return Ok(Self::State);
 		} else if type_is_path(ty, "CallLocation").is_some() {
 			return Ok(Self::Location);
-		} else if type_is_path(ty, "LazyVal").is_some() {
+		} else if type_is_path(ty, "Thunk").is_some() {
 			return Ok(Self::Lazy {
 				is_option: false,
 				name: ident.to_string(),
@@ -163,7 +163,7 @@
 		}
 
 		let (is_option, ty) = if let Some(ty) = extract_type_from_option(ty)? {
-			if type_is_path(ty, "LazyVal").is_some() {
+			if type_is_path(ty, "Thunk").is_some() {
 				return Ok(Self::Lazy {
 					is_option: true,
 					name: ident.to_string(),

--- a/crates/jrsonnet-parser/Cargo.toml
+++ b/crates/jrsonnet-parser/Cargo.toml
@@ -6,6 +6,9 @@
 license = "MIT"
 edition = "2021"
 
+[features]
+exp-destruct = []
+
 [dependencies]
 jrsonnet-interner = { path = "../jrsonnet-interner", version = "0.4.2" }
 

--- a/crates/jrsonnet-parser/src/expr.rs
+++ b/crates/jrsonnet-parser/src/expr.rs
@@ -179,10 +179,44 @@
 
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 #[derive(Debug, Clone, PartialEq, Trace)]
-pub struct BindSpec {
-	pub name: IStr,
-	pub params: Option<ParamsDesc>,
-	pub value: LocExpr,
+pub enum DestructRest {
+	/// ...rest
+	Keep(IStr),
+	/// ...
+	Drop,
+}
+
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[derive(Debug, Clone, PartialEq, Trace)]
+pub enum Destruct {
+	Full(IStr),
+	#[cfg(feature = "exp-destruct")]
+	Skip,
+	#[cfg(feature = "exp-destruct")]
+	Array {
+		start: Vec<Destruct>,
+		rest: Option<DestructRest>,
+		end: Vec<Destruct>,
+	},
+	#[cfg(feature = "exp-destruct")]
+	Object {
+		fields: Vec<(IStr, Option<Destruct>)>,
+		rest: Option<DestructRest>,
+	},
+}
+
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[derive(Debug, Clone, PartialEq, Trace)]
+pub enum BindSpec {
+	Field {
+		into: Destruct,
+		value: LocExpr,
+	},
+	Function {
+		name: IStr,
+		params: ParamsDesc,
+		value: LocExpr,
+	},
 }
 
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]

--- a/crates/jrsonnet-parser/src/lib.rs
+++ b/crates/jrsonnet-parser/src/lib.rs
@@ -55,18 +55,18 @@
 
 		/// Reserved word followed by any non-alphanumberic
 		rule reserved() = ("assert" / "else" / "error" / "false" / "for" / "function" / "if" / "import" / "importstr" / "importbin" / "in" / "local" / "null" / "tailstrict" / "then" / "self" / "super" / "true") end_of_ident()
-		rule id() = quiet!{ !reserved() alpha() (alpha() / digit())*} / expected!("<identifier>")
+		rule id() -> IStr = v:$(quiet!{ !reserved() alpha() (alpha() / digit())*} / expected!("<identifier>")) { v.into() }
 
 		rule keyword(id: &'static str) -> ()
 			= ##parse_string_literal(id) end_of_ident()
 
-		pub rule param(s: &ParserSettings) -> expr::Param = name:$(id()) expr:(_ "=" _ expr:expr(s){expr})? { expr::Param(name.into(), expr) }
+		pub rule param(s: &ParserSettings) -> expr::Param = name:id() expr:(_ "=" _ expr:expr(s){expr})? { expr::Param(name, expr) }
 		pub rule params(s: &ParserSettings) -> expr::ParamsDesc
 			= params:param(s) ** comma() comma()? { expr::ParamsDesc(Rc::new(params)) }
 			/ { expr::ParamsDesc(Rc::new(Vec::new())) }
 
 		pub rule arg(s: &ParserSettings) -> (Option<IStr>, LocExpr)
-			= quiet! { name:(s:$(id()) _ "=" _ {s})? expr:expr(s) {(name.map(Into::into), expr)} }
+			= quiet! { name:(s:id() _ "=" _ {s})? expr:expr(s) {(name, expr)} }
 			/ expected!("<argument>")
 
 		pub rule args(s: &ParserSettings) -> expr::ArgsDesc
@@ -89,9 +89,52 @@
 				Ok(expr::ArgsDesc::new(unnamed, named))
 			}
 
+		pub rule destruct_rest() -> expr::DestructRest
+			= "..." into:(_ into:id() {into})? {if let Some(into) = into {
+				expr::DestructRest::Keep(into)
+			} else {expr::DestructRest::Drop}}
+		pub rule destruct_array(s: &ParserSettings) -> expr::Destruct
+			= "[" _ start:destruct(s)**comma() rest:(
+				comma() _ rest:destruct_rest()? end:(
+					comma() end:destruct(s)**comma() (_ comma())? {end}
+					/ comma()? {Vec::new()}
+				) {(rest, end)}
+				/ comma()? {(None, Vec::new())}
+			) _ "]" {?
+				#[cfg(feature = "exp-destruct")] return Ok(expr::Destruct::Array {
+					start,
+					rest: rest.0,
+					end: rest.1,
+				});
+				#[cfg(not(feature = "exp-destruct"))] Err("experimental destructuring was not enabled")
+			}
+		pub rule destruct_object(s: &ParserSettings) -> expr::Destruct
+			= "{" _
+				fields:(name:id() _ into:(":" _ into:destruct(s) {into})? {(name, into)})**comma()
+				rest:(
+					comma() rest:destruct_rest()? {rest}
+					/ comma()? {None}
+				)
+			_ "}" {?
+				#[cfg(feature = "exp-destruct")] return Ok(expr::Destruct::Object {
+					fields,
+					rest,
+				});
+				#[cfg(not(feature = "exp-destruct"))] Err("experimental destructuring was not enabled")
+			}
+		pub rule destruct(s: &ParserSettings) -> expr::Destruct
+			= v:id() {expr::Destruct::Full(v)}
+			/ "?" {?
+				#[cfg(feature = "exp-destruct")] return Ok(expr::Destruct::Skip);
+				#[cfg(not(feature = "exp-destruct"))] Err("experimental destructuring was not enabled")
+			}
+			/ arr:destruct_array(s) {arr}
+			/ obj:destruct_object(s) {obj}
+
 		pub rule bind(s: &ParserSettings) -> expr::BindSpec
-			= name:$(id()) _ "=" _ expr:expr(s) {expr::BindSpec{name:name.into(), params: None, value: expr}}
-			/ name:$(id()) _ "(" _ params:params(s) _ ")" _ "=" _ expr:expr(s) {expr::BindSpec{name:name.into(), params: Some(params), value: expr}}
+			= into:destruct(s) _ "=" _ expr:expr(s) {expr::BindSpec::Field{into, value: expr}}
+			/ name:id() _ "(" _ params:params(s) _ ")" _ "=" _ expr:expr(s) {expr::BindSpec::Function{name, params, value: expr}}
+
 		pub rule assertion(s: &ParserSettings) -> expr::AssertStmt
 			= keyword("assert") _ cond:expr(s) msg:(_ ":" _ e:expr(s) {e})? { expr::AssertStmt(cond, msg) }
 
@@ -122,7 +165,7 @@
 			/ string_block() } / expected!("<string>")
 
 		pub rule field_name(s: &ParserSettings) -> expr::FieldName
-			= name:$(id()) {expr::FieldName::Fixed(name.into())}
+			= name:id() {expr::FieldName::Fixed(name.into())}
 			/ name:string() {expr::FieldName::Fixed(name.into())}
 			/ "[" _ expr:expr(s) _ "]" {expr::FieldName::Dyn(expr)}
 		pub rule visibility() -> expr::Visibility
@@ -167,7 +210,7 @@
 		pub rule ifspec(s: &ParserSettings) -> IfSpecData
 			= keyword("if") _ expr:expr(s) {IfSpecData(expr)}
 		pub rule forspec(s: &ParserSettings) -> ForSpecData
-			= keyword("for") _ id:$(id()) _ keyword("in") _ cond:expr(s) {ForSpecData(id.into(), cond)}
+			= keyword("for") _ id:id() _ keyword("in") _ cond:expr(s) {ForSpecData(id, cond)}
 		pub rule compspec(s: &ParserSettings) -> Vec<expr::CompSpec>
 			= s:(i:ifspec(s) { expr::CompSpec::IfSpec(i) } / f:forspec(s) {expr::CompSpec::ForSpec(f)} ) ** _ {s}
 		pub rule local_expr(s: &ParserSettings) -> Expr
@@ -187,9 +230,9 @@
 		pub rule number_expr(s: &ParserSettings) -> Expr
 			= n:number() { expr::Expr::Num(n) }
 		pub rule var_expr(s: &ParserSettings) -> Expr
-			= n:$(id()) { expr::Expr::Var(n.into()) }
+			= n:id() { expr::Expr::Var(n) }
 		pub rule id_loc(s: &ParserSettings) -> LocExpr
-			= a:position!() n:$(id()) b:position!() { LocExpr(Rc::new(expr::Expr::Str(n.into())), ExprLocation(s.file_name.clone(), a,b)) }
+			= a:position!() n:id() b:position!() { LocExpr(Rc::new(expr::Expr::Str(n)), ExprLocation(s.file_name.clone(), a,b)) }
 		pub rule if_then_else_expr(s: &ParserSettings) -> Expr
 			= cond:ifspec(s) _ keyword("then") _ cond_then:expr(s) cond_else:(_ keyword("else") _ e:expr(s) {e})? {Expr::IfElse{
 				cond,
@@ -212,7 +255,7 @@
 
 			/ quiet!{"$intrinsicThisFile" {Expr::IntrinsicThisFile}}
 			/ quiet!{"$intrinsicId" {Expr::IntrinsicId}}
-			/ quiet!{"$intrinsic(" name:$(id()) ")" {Expr::Intrinsic(name.into())}}
+			/ quiet!{"$intrinsic(" name:id() ")" {Expr::Intrinsic(name)}}
 
 			/ string_expr(s) / number_expr(s)
 			/ array_expr(s)
@@ -693,9 +736,8 @@
 						ObjExtend(
 							el!(Obj(ObjBody::MemberList(vec![])), 0, 2),
 							ObjBody::MemberList(vec![
-								Member::BindStmt(BindSpec {
-									name: "x".into(),
-									params: None,
+								Member::BindStmt(BindSpec::Field {
+									into: Destruct::Full("x".into()),
 									value: el!(Num(1.0), 15, 16)
 								}),
 								Member::Field(FieldMember {