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

difftreelog

refactor split Typed into FromUntyped and IntoUntyped

ysonnywlYaroslav Bolyukin2026-03-22parent: #8667194.patch.diff
in: master

20 files changed

modifiedbindings/jsonnet/src/native.rsdiffbeforeafterboth
--- a/bindings/jsonnet/src/native.rs
+++ b/bindings/jsonnet/src/native.rs
@@ -6,7 +6,7 @@
 use jrsonnet_evaluator::{
 	error::{Error, ErrorKind},
 	function::builtin::{NativeCallback, NativeCallbackHandler},
-	typed::Typed,
+	typed::FromUntyped as _,
 	IStr, Val,
 };
modifiedcmds/jrsonnet/Cargo.tomldiffbeforeafterboth
--- a/cmds/jrsonnet/Cargo.toml
+++ b/cmds/jrsonnet/Cargo.toml
@@ -11,10 +11,6 @@
 workspace = true
 
 [features]
-default = [
-    "exp-regex",
-]
-
 experimental = [
     "exp-preserve-order",
     "exp-destruct",
modifiedcrates/jrsonnet-evaluator/src/arr/mod.rsdiffbeforeafterboth
--- a/crates/jrsonnet-evaluator/src/arr/mod.rs
+++ b/crates/jrsonnet-evaluator/src/arr/mod.rs
@@ -5,11 +5,11 @@
 	rc::Rc,
 };
 
-use jrsonnet_gcmodule::{cc_dyn, Cc, Trace};
+use jrsonnet_gcmodule::{cc_dyn, Cc};
 use jrsonnet_interner::IBytes;
 use jrsonnet_parser::{Expr, Spanned};
 
-use crate::{function::NativeFn, typed::Typed, Context, Result, Thunk, Val};
+use crate::{function::NativeFn, Context, Result, Thunk, Val};
 
 mod spec;
 pub use spec::{ArrayLike, *};
@@ -241,4 +241,3 @@
 		self.0.is_cheap()
 	}
 }
-
modifiedcrates/jrsonnet-evaluator/src/arr/spec.rsdiffbeforeafterboth
--- a/crates/jrsonnet-evaluator/src/arr/spec.rs
+++ b/crates/jrsonnet-evaluator/src/arr/spec.rs
@@ -8,8 +8,11 @@
 use super::ArrValue;
 use crate::function::NativeFn;
 use crate::{
-	error::ErrorKind::InfiniteRecursionDetected, evaluate, typed::Typed, val::ThunkValue, Context,
-	Error, ObjValue, Result, Thunk, Val,
+	error::ErrorKind::InfiniteRecursionDetected,
+	evaluate,
+	typed::{IntoUntyped, Typed},
+	val::ThunkValue,
+	Context, Error, ObjValue, Result, Thunk, Val,
 };
 
 pub trait ArrayLike: Any + Trace + Debug {
modifiedcrates/jrsonnet-evaluator/src/evaluate/mod.rsdiffbeforeafterboth
--- a/crates/jrsonnet-evaluator/src/evaluate/mod.rs
+++ b/crates/jrsonnet-evaluator/src/evaluate/mod.rs
@@ -20,7 +20,7 @@
 	function::{CallLocation, FuncDesc, FuncVal},
 	gc::WithCapacityExt as _,
 	in_frame,
-	typed::Typed,
+	typed::{FromUntyped, IntoUntyped as _, Typed},
 	val::{CachedUnbound, IndexableVal, NumValue, StrValue, Thunk},
 	with_state, Context, Error, ObjValue, ObjValueBuilder, ObjectAssertion, Pending, Result,
 	ResultExt, SupThis, Unbound, Val,
@@ -620,7 +620,7 @@
 			}
 		}
 		Slice(slice) => {
-			fn parse_idx<T: Typed>(
+			fn parse_idx<T: Typed + FromUntyped>(
 				loc: CallLocation<'_>,
 				ctx: Context,
 				expr: Option<&Spanned<Expr>>,
modifiedcrates/jrsonnet-evaluator/src/evaluate/operator.rsdiffbeforeafterboth
--- a/crates/jrsonnet-evaluator/src/evaluate/operator.rs
+++ b/crates/jrsonnet-evaluator/src/evaluate/operator.rs
@@ -8,7 +8,7 @@
 	error::ErrorKind::*,
 	evaluate,
 	stdlib::std_format,
-	typed::Typed,
+	typed::IntoUntyped as _,
 	val::{equals, StrValue},
 	Context, Result, Val,
 };
modifiedcrates/jrsonnet-evaluator/src/function/native.rsdiffbeforeafterboth
--- a/crates/jrsonnet-evaluator/src/function/native.rs
+++ b/crates/jrsonnet-evaluator/src/function/native.rs
@@ -3,7 +3,11 @@
 use jrsonnet_gcmodule::Trace;
 
 use super::PreparedFuncVal;
-use crate::{bail, function::FuncVal, typed::Typed, CallLocation, Result, Val};
+use crate::{
+	function::FuncVal,
+	typed::{FromUntyped, IntoUntyped, Typed},
+	CallLocation, Result, Val,
+};
 use jrsonnet_types::{ComplexValType, ValType};
 
 #[derive(Debug, Trace, Clone)]
@@ -12,8 +16,8 @@
 	($i:expr; $($gen:ident)*) => {
 		impl<$($gen,)* O> NativeFn<($($gen,)* O,)>
 		where
-			$($gen: Typed,)*
-			O: Typed,
+			$($gen: Typed + IntoUntyped,)*
+			O: Typed + FromUntyped,
 		{
 			#[allow(non_snake_case, clippy::too_many_arguments)]
 			pub fn call(
@@ -22,7 +26,7 @@
 			) -> Result<O> {
 				let val = self.0.call(
 					CallLocation::native(),
-					&[$(Typed::into_lazy_untyped($gen),)*],
+					&[$(IntoUntyped::into_lazy_untyped($gen),)*],
 					&[],
 				)?;
 				O::from_untyped(val)
@@ -30,11 +34,9 @@
 		}
 		impl<$($gen,)* O> Typed for NativeFn<($($gen,)* O,)> {
 			const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Func);
-
-			fn into_untyped(_typed: Self) -> Result<Val> {
-				bail!("can only convert functions from jsonnet to native")
-			}
+		}
 
+		impl<$($gen,)* O> FromUntyped for NativeFn<($($gen,)* O,)> {
 			fn from_untyped(untyped: Val) -> Result<Self> {
 				let func = FuncVal::from_untyped(untyped)?;
 				Ok(Self(
modifiedcrates/jrsonnet-evaluator/src/stdlib/format.rsdiffbeforeafterboth
--- a/crates/jrsonnet-evaluator/src/stdlib/format.rs
+++ b/crates/jrsonnet-evaluator/src/stdlib/format.rs
@@ -9,7 +9,7 @@
 use crate::{
 	bail,
 	error::{format_found, suggest_object_fields, ErrorKind::*},
-	typed::Typed,
+	typed::FromUntyped,
 	Error, ObjValue, Result, Val,
 };
modifiedcrates/jrsonnet-evaluator/src/typed/conversions.rsdiffbeforeafterboth
1use std::{collections::BTreeMap, marker::PhantomData, ops::Deref};1use std::{collections::BTreeMap, marker::PhantomData, ops::Deref};
22
3use jrsonnet_gcmodule::{Cc, Trace};3use jrsonnet_gcmodule::Trace;
4use jrsonnet_interner::{IBytes, IStr};4use jrsonnet_interner::{IBytes, IStr};
5pub use jrsonnet_macros::Typed;5pub use jrsonnet_macros::Typed;
6use jrsonnet_types::{ComplexValType, ValType};6use jrsonnet_types::{ComplexValType, ValType};
77
8use crate::{8use crate::{
9	arr::{ArrValue, BytesArray},9	arr::{ArrValue, BytesArray},
10	bail,10	bail,
11	function::{FuncDesc, FuncVal},11	function::FuncVal,
12	typed::CheckType,12	typed::CheckType,
13	val::{IndexableVal, NumValue, StrValue, ThunkMapper},13	val::{IndexableVal, NumValue, StrValue, ThunkMapper},
14	ObjValue, ObjValueBuilder, Result, ResultExt, Thunk, Val,14	ObjValue, ObjValueBuilder, Result, ResultExt, Thunk, Val,
15};15};
1616
17#[derive(Trace)]17#[derive(Trace)]
18struct FromUntyped<K: Trace>(PhantomData<fn() -> K>);18struct ThunkFromUntyped<K: Trace>(PhantomData<fn() -> K>);
19impl<K> ThunkMapper<Val> for FromUntyped<K>19impl<K> ThunkMapper<Val> for ThunkFromUntyped<K>
20where20where
21	K: Typed + Trace,21	K: Typed + FromUntyped + Trace,
22{22{
23	type Output = K;23	type Output = K;
2424
25	fn map(self, from: Val) -> Result<Self::Output> {25	fn map(self, from: Val) -> Result<Self::Output> {
26		K::from_untyped(from)26		K::from_untyped(from)
27	}27	}
28}28}
29impl<K: Trace> Default for FromUntyped<K> {29impl<K: Trace> Default for ThunkFromUntyped<K> {
30	fn default() -> Self {30	fn default() -> Self {
31		Self(PhantomData)31		Self(PhantomData)
32	}32	}
33}33}
34#[derive(Trace)]
35struct ThunkIntoUntyped<K: Trace>(PhantomData<fn() -> K>);
36impl<K> ThunkMapper<K> for ThunkIntoUntyped<K>
37where
38	K: Typed + Trace + IntoUntyped,
39{
40	type Output = Val;
41
42	fn map(self, from: K) -> Result<Self::Output> {
43		K::into_untyped(from)
44	}
45}
46impl<K: Trace> Default for ThunkIntoUntyped<K> {
47	fn default() -> Self {
48		Self(PhantomData)
49	}
50}
3451
35pub trait TypedObj: Typed {52pub trait TypedObj: Typed {
36	fn serialize(self, out: &mut ObjValueBuilder) -> Result<()>;53	fn serialize(self, out: &mut ObjValueBuilder) -> Result<()>;
42	}59	}
43}60}
4461
45pub trait Typed: Sized {62pub trait Typed: Sized {
46	const TYPE: &'static ComplexValType;63	const TYPE: &'static ComplexValType;
64}
65pub trait IntoUntyped: Typed {
66	// Whatever caller should use `into_lazy_untyped` instead of `into_untyped`
67	fn provides_lazy() -> bool {
68		false
69	}
47	fn into_untyped(typed: Self) -> Result<Val>;70	fn into_untyped(typed: Self) -> Result<Val>;
48	fn into_lazy_untyped(typed: Self) -> Thunk<Val> {71	fn into_lazy_untyped(typed: Self) -> Thunk<Val> {
49		Thunk::from(Self::into_untyped(typed))72		Thunk::from(Self::into_untyped(typed))
50	}73	}
74}
75pub trait IntoUntypedResult: Typed {
76	/// Hack to make builtins be able to return non-result values, and make macros able to convert those values to result
77	/// This method returns identity in impl Typed for Result, and should not be overriden
78	#[doc(hidden)]
79	fn into_untyped_result(typed: Self) -> Result<Val>;
80}
81impl<T> IntoUntypedResult for T
82where
83	T: IntoUntyped,
84{
85	fn into_untyped_result(typed: Self) -> Result<Val> {
86		T::into_untyped(typed)
87	}
88}
89
90pub trait FromUntyped: Typed {
51	fn from_untyped(untyped: Val) -> Result<Self>;91	fn from_untyped(untyped: Val) -> Result<Self>;
52	fn from_lazy_untyped(lazy: Thunk<Val>) -> Result<Self> {92	fn from_lazy_untyped(lazy: Thunk<Val>) -> Result<Self> {
53		Self::from_untyped(lazy.evaluate()?)93		Self::from_untyped(lazy.evaluate()?)
54	}94	}
55
56	// Whatever caller should use `into_lazy_untyped` instead of `into_untyped`
57	fn provides_lazy() -> bool {
58		false
59	}
6095
61	// Whatever caller should use `from_lazy_untyped` instead of `from_untyped` when possible96	// Whatever caller should use `from_lazy_untyped` instead of `from_untyped` when possible
62	fn wants_lazy() -> bool {97	fn wants_lazy() -> bool {
63		false98		false
64	}99	}
65100}
66	/// Hack to make builtins be able to return non-result values, and make macros able to convert those values to result
67	/// This method returns identity in impl Typed for Result, and should not be overriden
68	#[doc(hidden)]
69	fn into_result(typed: Self) -> Result<Val> {
70		let value = Self::into_untyped(typed)?;
71		Ok(value)
72	}
73}
74101
75impl<T> Typed for Thunk<T>102impl<T> Typed for Thunk<T>
76where103where
77	T: Typed + Trace + Clone,104	T: Typed + Trace + Clone,
78{105{
79	const TYPE: &'static ComplexValType = &ComplexValType::Lazy(T::TYPE);106	const TYPE: &'static ComplexValType = &ComplexValType::Lazy(T::TYPE);
80107}
108
109impl<T> IntoUntyped for Thunk<T>
110where
111	T: Typed + IntoUntyped + Trace + Clone,
112{
81	fn into_untyped(typed: Self) -> Result<Val> {113	fn into_untyped(typed: Self) -> Result<Val> {
82		T::into_untyped(typed.evaluate()?)114		T::into_untyped(typed.evaluate()?)
83	}115	}
84
85	fn from_untyped(untyped: Val) -> Result<Self> {
86		Self::from_lazy_untyped(Thunk::evaluated(untyped))
87	}
88
89	fn provides_lazy() -> bool {116	fn provides_lazy() -> bool {
90		true117		true
91	}118	}
92119
93	fn into_lazy_untyped(inner: Self) -> Thunk<Val> {120	fn into_lazy_untyped(inner: Self) -> Thunk<Val> {
94		#[derive(Trace)]
95		struct IntoUntyped<K: Trace>(PhantomData<fn() -> K>);
96		impl<K> ThunkMapper<K> for IntoUntyped<K>
97		where
98			K: Typed + Trace,
99		{
100			type Output = Val;
101
102			fn map(self, from: K) -> Result<Self::Output> {
103				K::into_untyped(from)
104			}
105		}
106		impl<K: Trace> Default for IntoUntyped<K> {
107			fn default() -> Self {
108				Self(PhantomData)
109			}
110		}
111		inner.map(<IntoUntyped<T>>::default())121		inner.map(<ThunkIntoUntyped<T>>::default())
112	}122	}
123}
124
125impl<T> FromUntyped for Thunk<T>
126where
127	T: Typed + FromUntyped + Trace + Clone,
128{
129	fn from_untyped(untyped: Val) -> Result<Self> {
130		Self::from_lazy_untyped(Thunk::evaluated(untyped))
131	}
113132
114	fn wants_lazy() -> bool {133	fn wants_lazy() -> bool {
115		true134		true
116	}135	}
117136
118	fn from_lazy_untyped(inner: Thunk<Val>) -> Result<Self> {137	fn from_lazy_untyped(inner: Thunk<Val>) -> Result<Self> {
119		Ok(inner.map(<FromUntyped<T>>::default()))138		Ok(inner.map(<ThunkFromUntyped<T>>::default()))
120	}139	}
121}140}
122141
123pub const MAX_SAFE_INTEGER: f64 = ((1u64 << (f64::MANTISSA_DIGITS)) - 1) as f64;142pub const MAX_SAFE_INTEGER: f64 = ((1u64 << (f64::MANTISSA_DIGITS)) - 1) as f64;
124pub const MIN_SAFE_INTEGER: f64 = (-((1i64 << (f64::MANTISSA_DIGITS)) - 1)) as f64;143pub const MIN_SAFE_INTEGER: f64 = (-((1i64 << (f64::MANTISSA_DIGITS)) - 1)) as f64;
125144
126macro_rules! impl_int {145macro_rules! impl_int {
127	($($ty:ty)*) => {$(146	($($ty:ty)*) => {$(
128		impl Typed for $ty {147		impl Typed for $ty {
129			const TYPE: &'static ComplexValType =148			const TYPE: &'static ComplexValType =
130				&ComplexValType::BoundedNumber(Some(Self::MIN as f64), Some(Self::MAX as f64));149				&ComplexValType::BoundedNumber(Some(Self::MIN as f64), Some(Self::MAX as f64));
150		}
151		impl FromUntyped for $ty {
131			fn from_untyped(value: Val) -> Result<Self> {152			fn from_untyped(value: Val) -> Result<Self> {
132				<Self as Typed>::TYPE.check(&value)?;153				<Self as Typed>::TYPE.check(&value)?;
133				match value {154				match value {
145					_ => unreachable!(),166					_ => unreachable!(),
146				}167				}
147			}168			}
169		}
170		impl IntoUntyped for $ty {
148			fn into_untyped(value: Self) -> Result<Val> {171			fn into_untyped(value: Self) -> Result<Val> {
149				Ok(Val::Num(value.into()))172				Ok(Val::Num(value.into()))
150			}173			}
151		}174		}
152	)*};175	)*};
153}176}
154177
177			}200			}
178		}201		}
179202
180		impl<const MIN: $ty, const MAX: $ty> Typed for $name<MIN, MAX> {203		impl<const MIN: $ty, const MAX: $ty> Typed for $name<MIN, MAX> {
181			const TYPE: &'static ComplexValType =204			const TYPE: &'static ComplexValType =
182				&ComplexValType::BoundedNumber(205				&ComplexValType::BoundedNumber(
183					Some(MIN as f64),206					Some(MIN as f64),
184					Some(MAX as f64),207					Some(MAX as f64),
185				);208				);
186209		}
210
211		impl<const MIN: $ty, const MAX: $ty> FromUntyped for $name<MIN, MAX> {
187			fn from_untyped(value: Val) -> Result<Self> {212			fn from_untyped(value: Val) -> Result<Self> {
188				<Self as Typed>::TYPE.check(&value)?;213				<Self as Typed>::TYPE.check(&value)?;
189				match value {214				match value {
201					_ => unreachable!(),226					_ => unreachable!(),
202				}227				}
203			}228			}
204229		}
230
231		impl<const MIN: $ty, const MAX: $ty> IntoUntyped for $name<MIN, MAX> {
205			#[allow(clippy::cast_lossless)]232			#[allow(clippy::cast_lossless)]
206			fn into_untyped(value: Self) -> Result<Val> {233			fn into_untyped(value: Self) -> Result<Val> {
207				Ok(Val::try_num(value.0)?)234				Ok(Val::try_num(value.0)?)
208			}235			}
209		}236		}
210	)*};237	)*};
211}238}
212239
218	BoundedUsize = usize245	BoundedUsize = usize
219);246);
220247
221impl Typed for f64 {248impl Typed for f64 {
222	const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Num);249	const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Num);
223250}
251impl IntoUntyped for f64 {
224	fn into_untyped(value: Self) -> Result<Val> {252	fn into_untyped(value: Self) -> Result<Val> {
225		Ok(Val::try_num(value)?)253		Ok(Val::try_num(value)?)
226	}254	}
227255}
256impl FromUntyped for f64 {
228	fn from_untyped(value: Val) -> Result<Self> {257	fn from_untyped(value: Val) -> Result<Self> {
229		<Self as Typed>::TYPE.check(&value)?;258		<Self as Typed>::TYPE.check(&value)?;
230		match value {259		match value {
231			Val::Num(n) => Ok(n.get()),260			Val::Num(n) => Ok(n.get()),
232			_ => unreachable!(),261			_ => unreachable!(),
233		}262		}
234	}263	}
235}264}
236265
237pub struct PositiveF64(pub f64);266pub struct PositiveF64(pub f64);
238impl Typed for PositiveF64 {267impl Typed for PositiveF64 {
239	const TYPE: &'static ComplexValType = &ComplexValType::BoundedNumber(Some(0.0), None);268	const TYPE: &'static ComplexValType = &ComplexValType::BoundedNumber(Some(0.0), None);
240269}
270impl IntoUntyped for PositiveF64 {
241	fn into_untyped(value: Self) -> Result<Val> {271	fn into_untyped(value: Self) -> Result<Val> {
242		Ok(Val::try_num(value.0)?)272		Ok(Val::try_num(value.0)?)
243	}273	}
244274}
275impl FromUntyped for PositiveF64 {
245	fn from_untyped(value: Val) -> Result<Self> {276	fn from_untyped(value: Val) -> Result<Self> {
246		<Self as Typed>::TYPE.check(&value)?;277		<Self as Typed>::TYPE.check(&value)?;
247		match value {278		match value {
248			Val::Num(n) => Ok(Self(n.get())),279			Val::Num(n) => Ok(Self(n.get())),
249			_ => unreachable!(),280			_ => unreachable!(),
250		}281		}
251	}282	}
252}283}
253impl Typed for usize {284impl Typed for usize {
254	const TYPE: &'static ComplexValType =285	const TYPE: &'static ComplexValType =
255		&ComplexValType::BoundedNumber(Some(0.0), Some(MAX_SAFE_INTEGER));286		&ComplexValType::BoundedNumber(Some(0.0), Some(MAX_SAFE_INTEGER));
256287}
288impl IntoUntyped for usize {
257	fn into_untyped(value: Self) -> Result<Val> {289	fn into_untyped(value: Self) -> Result<Val> {
258		Ok(Val::try_num(value)?)290		Ok(Val::try_num(value)?)
259	}291	}
260292}
293impl FromUntyped for usize {
261	fn from_untyped(value: Val) -> Result<Self> {294	fn from_untyped(value: Val) -> Result<Self> {
262		<Self as Typed>::TYPE.check(&value)?;295		<Self as Typed>::TYPE.check(&value)?;
263		match value {296		match value {
272			_ => unreachable!(),305			_ => unreachable!(),
273		}306		}
274	}307	}
275}308}
276309
277impl Typed for IStr {310impl Typed for IStr {
278	const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Str);311	const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Str);
279312}
313impl IntoUntyped for IStr {
280	fn into_untyped(value: Self) -> Result<Val> {314	fn into_untyped(value: Self) -> Result<Val> {
281		Ok(Val::string(value))315		Ok(Val::string(value))
282	}316	}
283317}
318impl FromUntyped for IStr {
284	fn from_untyped(value: Val) -> Result<Self> {319	fn from_untyped(value: Val) -> Result<Self> {
285		<Self as Typed>::TYPE.check(&value)?;320		<Self as Typed>::TYPE.check(&value)?;
286		match value {321		match value {
287			Val::Str(s) => Ok(s.into_flat()),322			Val::Str(s) => Ok(s.into_flat()),
288			_ => unreachable!(),323			_ => unreachable!(),
289		}324		}
290	}325	}
291}326}
292327
293impl Typed for String {328impl Typed for String {
294	const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Str);329	const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Str);
295330}
331impl IntoUntyped for String {
296	fn into_untyped(value: Self) -> Result<Val> {332	fn into_untyped(value: Self) -> Result<Val> {
297		Ok(Val::string(value))333		Ok(Val::string(value))
298	}334	}
299335}
336impl FromUntyped for String {
300	fn from_untyped(value: Val) -> Result<Self> {337	fn from_untyped(value: Val) -> Result<Self> {
301		<Self as Typed>::TYPE.check(&value)?;338		<Self as Typed>::TYPE.check(&value)?;
302		match value {339		match value {
303			Val::Str(s) => Ok(s.to_string()),340			Val::Str(s) => Ok(s.to_string()),
304			_ => unreachable!(),341			_ => unreachable!(),
305		}342		}
306	}343	}
307}344}
308345
309impl Typed for StrValue {346impl Typed for StrValue {
310	const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Str);347	const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Str);
311348}
349impl IntoUntyped for StrValue {
312	fn into_untyped(value: Self) -> Result<Val> {350	fn into_untyped(value: Self) -> Result<Val> {
313		Ok(Val::Str(value))351		Ok(Val::Str(value))
314	}352	}
315353}
354impl FromUntyped for StrValue {
316	fn from_untyped(value: Val) -> Result<Self> {355	fn from_untyped(value: Val) -> Result<Self> {
317		<Self as Typed>::TYPE.check(&value)?;356		<Self as Typed>::TYPE.check(&value)?;
318		match value {357		match value {
319			Val::Str(s) => Ok(s),358			Val::Str(s) => Ok(s),
320			_ => unreachable!(),359			_ => unreachable!(),
321		}360		}
322	}361	}
323}362}
324363
325impl Typed for char {364impl Typed for char {
326	const TYPE: &'static ComplexValType = &ComplexValType::Char;365	const TYPE: &'static ComplexValType = &ComplexValType::Char;
327366}
367impl IntoUntyped for char {
328	fn into_untyped(value: Self) -> Result<Val> {368	fn into_untyped(value: Self) -> Result<Val> {
329		Ok(Val::string(value))369		Ok(Val::string(value))
330	}370	}
331371}
372impl FromUntyped for char {
332	fn from_untyped(value: Val) -> Result<Self> {373	fn from_untyped(value: Val) -> Result<Self> {
333		<Self as Typed>::TYPE.check(&value)?;374		<Self as Typed>::TYPE.check(&value)?;
334		match value {375		match value {
335			Val::Str(s) => Ok(s.into_flat().chars().next().unwrap()),376			Val::Str(s) => Ok(s.into_flat().chars().next().unwrap()),
336			_ => unreachable!(),377			_ => unreachable!(),
337		}378		}
338	}379	}
339}380}
340381
382// TODO: View into vec using ArrayLike?
341impl<T> Typed for Vec<T>383impl<T> Typed for Vec<T>
342where384where
343	T: Typed,385	T: Typed,
344{386{
345	const TYPE: &'static ComplexValType = &ComplexValType::ArrayRef(T::TYPE);387	const TYPE: &'static ComplexValType = &ComplexValType::ArrayRef(T::TYPE);
346388}
389impl<T: Typed + IntoUntyped> IntoUntyped for Vec<T> {
347	fn into_untyped(value: Self) -> Result<Val> {390	fn into_untyped(value: Self) -> Result<Val> {
348		Ok(Val::Arr(391		Ok(Val::Arr(
349			value392			value
352				.collect::<Result<ArrValue>>()?,395				.collect::<Result<ArrValue>>()?,
353		))396		))
354	}397	}
355398}
399impl<T: Typed + FromUntyped> FromUntyped for Vec<T> {
356	fn from_untyped(value: Val) -> Result<Self> {400	fn from_untyped(value: Val) -> Result<Self> {
357		let Val::Arr(a) = value else {401		let Val::Arr(a) = value else {
358			<Self as Typed>::TYPE.check(&value)?;402			<Self as Typed>::TYPE.check(&value)?;
367			})411			})
368			.collect::<Result<Self>>()412			.collect::<Result<Self>>()
369	}413	}
370}414}
371415
416// TODO: View into BTreeMap using ObjectCore?
372impl<K: Typed + Ord, V: Typed> Typed for BTreeMap<K, V> {417impl<K, V> Typed for BTreeMap<K, V>
418where
419	K: Typed + Ord,
420	V: Typed,
421{
373	const TYPE: &'static ComplexValType = &ComplexValType::AttrsOf(V::TYPE);422	const TYPE: &'static ComplexValType = &ComplexValType::AttrsOf(V::TYPE);
374423}
424impl<K, V> IntoUntyped for BTreeMap<K, V>
425where
426	K: Typed + Ord + IntoUntyped,
427	V: Typed + IntoUntyped,
428{
375	fn into_untyped(typed: Self) -> Result<Val> {429	fn into_untyped(typed: Self) -> Result<Val> {
376		let mut out = ObjValueBuilder::with_capacity(typed.len());430		let mut out = ObjValueBuilder::with_capacity(typed.len());
377		for (k, v) in typed {431		for (k, v) in typed {
383		}437		}
384		Ok(Val::Obj(out.build()))438		Ok(Val::Obj(out.build()))
385	}439	}
386440}
441impl<K, V> FromUntyped for BTreeMap<K, V>
442where
443	K: FromUntyped + Ord,
444	V: FromUntyped,
445{
387	fn from_untyped(value: Val) -> Result<Self> {446	fn from_untyped(value: Val) -> Result<Self> {
388		Self::TYPE.check(&value)?;447		Self::TYPE.check(&value)?;
389		let obj = value.as_obj().expect("typecheck should fail");448		let obj = value.as_obj().expect("typecheck should fail");
412		}471		}
413		Ok(out)472		Ok(out)
414	}473	}
415}474}
416475
417impl Typed for Val {476impl Typed for Val {
418	const TYPE: &'static ComplexValType = &ComplexValType::Any;477	const TYPE: &'static ComplexValType = &ComplexValType::Any;
419478}
479impl IntoUntyped for Val {
420	fn into_untyped(typed: Self) -> Result<Val> {480	fn into_untyped(typed: Self) -> Result<Val> {
421		Ok(typed)481		Ok(typed)
422	}482	}
483}
484impl FromUntyped for Val {
423	fn from_untyped(untyped: Val) -> Result<Self> {485	fn from_untyped(untyped: Val) -> Result<Self> {
424		Ok(untyped)486		Ok(untyped)
425	}487	}
426}488}
427489
428// Hack
429#[doc(hidden)]490#[doc(hidden)]
430impl<T> Typed for Result<T>491impl<T> Typed for Result<T>
431where492where
432	T: Typed,493	T: Typed,
433{494{
434	const TYPE: &'static ComplexValType = &ComplexValType::Any;495	const TYPE: &'static ComplexValType = &ComplexValType::Any;
435496}
436	fn into_untyped(_typed: Self) -> Result<Val> {497impl<T: IntoUntyped> IntoUntypedResult for Result<T> {
437		panic!("do not use this conversion")
438	}
439
440	fn from_untyped(_untyped: Val) -> Result<Self> {
441		panic!("do not use this conversion")
442	}
443
444	fn into_result(typed: Self) -> Result<Val> {498	fn into_untyped_result(typed: Self) -> Result<Val> {
445		typed.map(T::into_untyped)?499		typed.map(T::into_untyped)?
446	}500	}
447}501}
448502
449/// Specialization503/// Specialization
450impl Typed for IBytes {504impl Typed for IBytes {
451	const TYPE: &'static ComplexValType =505	const TYPE: &'static ComplexValType =
452		&ComplexValType::ArrayRef(&ComplexValType::BoundedNumber(Some(0.0), Some(255.0)));506		&ComplexValType::ArrayRef(&ComplexValType::BoundedNumber(Some(0.0), Some(255.0)));
453507}
508impl IntoUntyped for IBytes {
454	fn into_untyped(value: Self) -> Result<Val> {509	fn into_untyped(value: Self) -> Result<Val> {
455		Ok(Val::Arr(ArrValue::bytes(value)))510		Ok(Val::Arr(ArrValue::bytes(value)))
456	}511	}
457512}
513impl FromUntyped for IBytes {
458	fn from_untyped(value: Val) -> Result<Self> {514	fn from_untyped(value: Val) -> Result<Self> {
459		let Val::Arr(a) = &value else {515		let Val::Arr(a) = &value else {
460			<Self as Typed>::TYPE.check(&value)?;516			<Self as Typed>::TYPE.check(&value)?;
472		}528		}
473		Ok(out.as_slice().into())529		Ok(out.as_slice().into())
474	}530	}
475}531}
476532
477pub struct M1;533pub struct M1;
478impl Typed for M1 {534impl Typed for M1 {
479	const TYPE: &'static ComplexValType = &ComplexValType::BoundedNumber(Some(-1.0), Some(-1.0));535	const TYPE: &'static ComplexValType = &ComplexValType::BoundedNumber(Some(-1.0), Some(-1.0));
480536}
537impl IntoUntyped for M1 {
481	fn into_untyped(_: Self) -> Result<Val> {538	fn into_untyped(_: Self) -> Result<Val> {
482		Ok(Val::Num(NumValue::new(-1.0).expect("finite")))539		Ok(Val::Num(NumValue::new(-1.0).expect("finite")))
483	}540	}
484541}
542impl FromUntyped for M1 {
485	fn from_untyped(value: Val) -> Result<Self> {543	fn from_untyped(value: Val) -> Result<Self> {
486		<Self as Typed>::TYPE.check(&value)?;544		<Self as Typed>::TYPE.check(&value)?;
487		Ok(Self)545		Ok(Self)
488	}546	}
489}547}
490548
491macro_rules! decl_either {549macro_rules! decl_either {
492	($($name: ident, $($id: ident)*);*) => {$(550	($($name: ident, $($id: ident)*);*) => {$(
497		impl<$($id),*> Typed for $name<$($id),*>555		impl<$($id),*> Typed for $name<$($id),*>
498		where556		where
499			$($id: Typed,)*557			$($id: Typed,)*
500		{558		{
501			const TYPE: &'static ComplexValType = &ComplexValType::UnionRef(&[$($id::TYPE),*]);559			const TYPE: &'static ComplexValType = &ComplexValType::UnionRef(&[$($id::TYPE),*]);
502560		}
561		impl<$($id),*> IntoUntyped for $name<$($id),*>
562		where
563			$($id: Typed + IntoUntyped,)*
564		{
503			fn into_untyped(value: Self) -> Result<Val> {565			fn into_untyped(value: Self) -> Result<Val> {
504				match value {$(566				match value {$(
505					$name::$id(v) => $id::into_untyped(v)567					$name::$id(v) => $id::into_untyped(v)
506				),*}568				),*}
507			}569			}
508570		}
571
572		impl<$($id),*> FromUntyped for $name<$($id),*>
573		where
574			$($id: Typed + FromUntyped,)*
575		{
509			fn from_untyped(value: Val) -> Result<Self> {576			fn from_untyped(value: Val) -> Result<Self> {
510				$(577				$(
511					if $id::TYPE.check(&value).is_ok() {578					if $id::TYPE.check(&value).is_ok() {
516					unreachable!()583					unreachable!()
517				}584				}
518			}585			}
519		}586		}
520	)*}587	)*}
521}588}
522decl_either!(589decl_either!(
542609
543pub type MyType = Either![u32, f64, String];610pub type MyType = Either![u32, f64, String];
544611
545impl Typed for ArrValue {612impl Typed for ArrValue {
546	const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Arr);613	const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Arr);
547614}
615impl IntoUntyped for ArrValue {
548	fn into_untyped(value: Self) -> Result<Val> {616	fn into_untyped(value: Self) -> Result<Val> {
549		Ok(Val::Arr(value))617		Ok(Val::Arr(value))
550	}618	}
551619}
620impl FromUntyped for ArrValue {
552	fn from_untyped(value: Val) -> Result<Self> {621	fn from_untyped(value: Val) -> Result<Self> {
553		<Self as Typed>::TYPE.check(&value)?;622		<Self as Typed>::TYPE.check(&value)?;
554		match value {623		match value {
555			Val::Arr(a) => Ok(a),624			Val::Arr(a) => Ok(a),
556			_ => unreachable!(),625			_ => unreachable!(),
557		}626		}
558	}627	}
559}628}
560629
561impl Typed for FuncVal {630impl Typed for FuncVal {
562	const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Func);631	const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Func);
563632}
633impl IntoUntyped for FuncVal {
564	fn into_untyped(value: Self) -> Result<Val> {634	fn into_untyped(value: Self) -> Result<Val> {
565		Ok(Val::Func(value))635		Ok(Val::Func(value))
566	}636	}
567637}
638impl FromUntyped for FuncVal {
568	fn from_untyped(value: Val) -> Result<Self> {639	fn from_untyped(value: Val) -> Result<Self> {
569		<Self as Typed>::TYPE.check(&value)?;640		<Self as Typed>::TYPE.check(&value)?;
570		match value {641		match value {
571			Val::Func(a) => Ok(a),642			Val::Func(a) => Ok(a),
572			_ => unreachable!(),643			_ => unreachable!(),
573		}644		}
574	}645	}
575}646}
576647
577impl Typed for Cc<FuncDesc> {648impl Typed for ObjValue {
578	const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Func);649	const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Obj);
579
580	fn into_untyped(value: Self) -> Result<Val> {
581		Ok(Val::Func(FuncVal::Normal(value)))
582	}
583
584	fn from_untyped(value: Val) -> Result<Self> {
585		<Self as Typed>::TYPE.check(&value)?;
586		match value {
587			Val::Func(FuncVal::Normal(desc)) => Ok(desc),
588			Val::Func(_) => bail!("expected normal function, not builtin"),
589			_ => unreachable!(),
590		}
591	}
592}650}
593
594impl Typed for ObjValue {651impl IntoUntyped for ObjValue {
595	const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Obj);
596
597	fn into_untyped(value: Self) -> Result<Val> {652	fn into_untyped(value: Self) -> Result<Val> {
598		Ok(Val::Obj(value))653		Ok(Val::Obj(value))
599	}654	}
600655}
656impl FromUntyped for ObjValue {
601	fn from_untyped(value: Val) -> Result<Self> {657	fn from_untyped(value: Val) -> Result<Self> {
602		<Self as Typed>::TYPE.check(&value)?;658		<Self as Typed>::TYPE.check(&value)?;
603		match value {659		match value {
604			Val::Obj(a) => Ok(a),660			Val::Obj(a) => Ok(a),
605			_ => unreachable!(),661			_ => unreachable!(),
606		}662		}
607	}663	}
608}664}
609665
610impl Typed for bool {666impl Typed for bool {
611	const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Bool);667	const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Bool);
612668}
669impl IntoUntyped for bool {
613	fn into_untyped(value: Self) -> Result<Val> {670	fn into_untyped(value: Self) -> Result<Val> {
614		Ok(Val::Bool(value))671		Ok(Val::Bool(value))
615	}672	}
616673}
674impl FromUntyped for bool {
617	fn from_untyped(value: Val) -> Result<Self> {675	fn from_untyped(value: Val) -> Result<Self> {
618		<Self as Typed>::TYPE.check(&value)?;676		<Self as Typed>::TYPE.check(&value)?;
619		match value {677		match value {
620			Val::Bool(a) => Ok(a),678			Val::Bool(a) => Ok(a),
621			_ => unreachable!(),679			_ => unreachable!(),
622		}680		}
623	}681	}
624}682}
683
625impl Typed for IndexableVal {684impl Typed for IndexableVal {
626	const TYPE: &'static ComplexValType = &ComplexValType::UnionRef(&[685	const TYPE: &'static ComplexValType = &ComplexValType::UnionRef(&[
627		&ComplexValType::Simple(ValType::Arr),686		&ComplexValType::Simple(ValType::Arr),
628		&ComplexValType::Simple(ValType::Str),687		&ComplexValType::Simple(ValType::Str),
629	]);688	]);
630689}
690impl IntoUntyped for IndexableVal {
631	fn into_untyped(value: Self) -> Result<Val> {691	fn into_untyped(value: Self) -> Result<Val> {
632		match value {692		match value {
633			Self::Str(s) => Ok(Val::string(s)),693			Self::Str(s) => Ok(Val::string(s)),
634			Self::Arr(a) => Ok(Val::Arr(a)),694			Self::Arr(a) => Ok(Val::Arr(a)),
635		}695		}
636	}696	}
637697}
698impl FromUntyped for IndexableVal {
638	fn from_untyped(value: Val) -> Result<Self> {699	fn from_untyped(value: Val) -> Result<Self> {
639		<Self as Typed>::TYPE.check(&value)?;700		<Self as Typed>::TYPE.check(&value)?;
640		value.into_indexable()701		value.into_indexable()
641	}702	}
642}703}
643704
644pub struct Null;705pub struct Null;
645impl Typed for Null {706impl Typed for Null {
646	const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Null);707	const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Null);
647708}
709impl IntoUntyped for Null {
648	fn into_untyped(_: Self) -> Result<Val> {710	fn into_untyped(_: Self) -> Result<Val> {
649		Ok(Val::Null)711		Ok(Val::Null)
650	}712	}
651713}
714impl FromUntyped for Null {
652	fn from_untyped(value: Val) -> Result<Self> {715	fn from_untyped(value: Val) -> Result<Self> {
653		<Self as Typed>::TYPE.check(&value)?;716		<Self as Typed>::TYPE.check(&value)?;
654		Ok(Self)717		Ok(Self)
655	}718	}
656}719}
657720
658impl<T> Typed for Option<T>721impl<T> Typed for Option<T>
659where722where
660	T: Typed,723	T: Typed,
661{724{
662	const TYPE: &'static ComplexValType =725	const TYPE: &'static ComplexValType =
663		&ComplexValType::UnionRef(&[&ComplexValType::Simple(ValType::Null), T::TYPE]);726		&ComplexValType::UnionRef(&[&ComplexValType::Simple(ValType::Null), T::TYPE]);
664727}
728impl<T> IntoUntyped for Option<T>
729where
730	T: Typed + IntoUntyped,
731{
665	fn into_untyped(typed: Self) -> Result<Val> {732	fn into_untyped(typed: Self) -> Result<Val> {
666		typed.map_or_else(|| Ok(Val::Null), |v| T::into_untyped(v))733		typed.map_or_else(|| Ok(Val::Null), |v| T::into_untyped(v))
667	}734	}
668735}
736impl<T> FromUntyped for Option<T>
737where
738	T: Typed + FromUntyped,
739{
669	fn from_untyped(untyped: Val) -> Result<Self> {740	fn from_untyped(untyped: Val) -> Result<Self> {
670		if matches!(untyped, Val::Null) {741		if matches!(untyped, Val::Null) {
671			Ok(None)742			Ok(None)
672		} else {743		} else {
673			T::from_untyped(untyped).map(Some)744			T::from_untyped(untyped).map(Some)
674		}745		}
675	}746	}
676}747}
677748
678impl Typed for NumValue {749impl Typed for NumValue {
679	const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Num);750	const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Num);
680751}
752impl IntoUntyped for NumValue {
681	fn into_untyped(typed: Self) -> Result<Val> {753	fn into_untyped(typed: Self) -> Result<Val> {
682		Ok(Val::Num(typed))754		Ok(Val::Num(typed))
683	}755	}
684756}
757impl FromUntyped for NumValue {
685	fn from_untyped(untyped: Val) -> Result<Self> {758	fn from_untyped(untyped: Val) -> Result<Self> {
686		Self::TYPE.check(&untyped)?;759		Self::TYPE.check(&untyped)?;
687		match untyped {760		match untyped {
688			Val::Num(v) => Ok(v),761			Val::Num(v) => Ok(v),
689			_ => unreachable!(),762			_ => unreachable!(),
690		}763		}
691	}764	}
692}765}
693766
modifiedcrates/jrsonnet-interner/src/names.rsdiffbeforeafterboth
--- a/crates/jrsonnet-interner/src/names.rs
+++ b/crates/jrsonnet-interner/src/names.rs
@@ -0,0 +1 @@
+
modifiedcrates/jrsonnet-macros/src/lib.rsdiffbeforeafterboth
--- a/crates/jrsonnet-macros/src/lib.rs
+++ b/crates/jrsonnet-macros/src/lib.rs
@@ -8,15 +8,15 @@
 	parse_macro_input,
 	punctuated::Punctuated,
 	spanned::Spanned,
-	token::{self, Comma},
+	token::Comma,
 	Attribute, DeriveInput, Error, Expr, ExprClosure, FnArg, GenericArgument, Ident, ItemFn,
 	LitStr, Meta, Pat, Path, PathArguments, Result, ReturnType, Token, Type,
 };
 
 use self::typed::derive_typed_inner;
 
+mod names;
 mod typed;
-mod names;
 
 fn try_parse_attr_noargs<I>(attrs: &[Attribute], ident: I) -> Result<bool>
 where
@@ -202,7 +202,7 @@
 			_ => {}
 		}
 
-		let (optionality, ty) = if try_parse_attr_noargs(&mut arg.attrs, "default")? {
+		let (optionality, ty) = if try_parse_attr_noargs(&arg.attrs, "default")? {
 			remove_attr(&mut arg.attrs, "default");
 			(Optionality::TypeDefault, ty.clone())
 		} else if let Some(default) = parse_attr::<_, _>(&arg.attrs, "default")? {
@@ -322,7 +322,7 @@
 				let name = name.as_ref().map_or("<unnamed>", String::as_str);
 				let eval = quote! {jrsonnet_evaluator::in_description_frame(
 					|| format!("argument <{}> evaluation", #name),
-					|| <#ty>::from_untyped(value.evaluate()?),
+					|| <#ty as FromUntyped>::from_untyped(value.evaluate()?),
 				)?};
 				let value = match optionality {
 					Optionality::Required => quote! {{
@@ -411,7 +411,7 @@
 			use ::jrsonnet_evaluator::{
 				State, Val,
 				function::{builtin::{Builtin, StaticBuiltin}, FunctionSignature, ParamParse, ParamName, ParamDefault, CallLocation},
-				Result, Context, typed::Typed,
+				Result, Context, typed::{Typed, FromUntyped, IntoUntypedResult},
 				parser::Span, params, Thunk,
 			};
 			params!(
@@ -432,7 +432,7 @@
 				#[allow(unused_variables)]
 				fn call(&self, location: CallLocation<'_>, parsed: &[Option<Thunk<Val>>]) -> Result<Val> {
 					let result: #result = #name(#(#pass)*);
-					<_ as Typed>::into_result(result)
+					<_ as IntoUntypedResult>::into_untyped_result(result)
 				}
 				fn as_any(&self) -> &dyn ::std::any::Any {
 					self
modifiedcrates/jrsonnet-macros/src/names.rsdiffbeforeafterboth
--- a/crates/jrsonnet-macros/src/names.rs
+++ b/crates/jrsonnet-macros/src/names.rs
@@ -1,6 +1,5 @@
 use proc_macro2::TokenStream;
 use quote::quote;
-use std::cell::RefCell;
 
 #[derive(Default)]
 pub struct Names {
modifiedcrates/jrsonnet-macros/src/typed.rsdiffbeforeafterboth
--- a/crates/jrsonnet-macros/src/typed.rs
+++ b/crates/jrsonnet-macros/src/typed.rs
@@ -178,7 +178,7 @@
 					None
 				};
 
-				__value.map(<#ty as Typed>::from_untyped).transpose()?
+				__value.map(<#ty as FromUntyped>::from_untyped).transpose()?
 			},
 		}
 	}
@@ -219,7 +219,7 @@
 					return Err(ErrorKind::NoSuchField(__names[#error_text].clone(), vec![]).into());
 				};
 
-				<#ty as Typed>::from_untyped(__value)?
+				<#ty as FromUntyped>::from_untyped(__value)?
 			},
 		}
 	}
@@ -258,14 +258,14 @@
 						out.field(__names[#name].clone())
 							#hide
 							#add
-							.try_thunk(<#ty as Typed>::into_lazy_untyped(value))?;
+							.try_thunk(<#ty as IntoUntyped>::into_lazy_untyped(value))?;
 					}
 				} else {
 					quote! {
 						out.field(__names[#name].clone())
 							#hide
 							#add
-							.try_value(<#ty as Typed>::into_untyped(value)?)?;
+							.try_value(<#ty as IntoUntyped>::into_untyped(value)?)?;
 					}
 				};
 				if self.is_option {
@@ -313,18 +313,21 @@
 				const TYPE: &'static ComplexValType = &ComplexValType::ObjectRef(&[
 					#(#fields,)*
 				]);
+			}
 
+			impl #impl_generics FromUntyped for #ident #ty_generics #where_clause {
 				fn from_untyped(value: Val) -> JrResult<Self> {
 					let obj = value.as_obj().expect("shape is correct");
 					Self::parse(&obj)
 				}
+			}
 
+			impl #impl_generics IntoUntyped for #ident #ty_generics #where_clause {
 				fn into_untyped(value: Self) -> JrResult<Val> {
 					let mut out = ObjValueBuilder::with_capacity(#capacity);
 					value.serialize(&mut out)?;
 					Ok(Val::Obj(out.build()))
 				}
-
 			}
 		}
 	};
@@ -344,7 +347,7 @@
 	Ok(quote! {
 		const _: () = {
 			use ::jrsonnet_evaluator::{
-				typed::{ComplexValType, Typed, TypedObj, CheckType},
+				typed::{ComplexValType, Typed, IntoUntyped, FromUntyped, TypedObj, CheckType},
 				Val, State,
 				error::{ErrorKind, Result as JrResult},
 				ObjValueBuilder, ObjValue, IStr,
modifiedcrates/jrsonnet-stdlib/src/arrays.rsdiffbeforeafterboth
--- a/crates/jrsonnet-stdlib/src/arrays.rs
+++ b/crates/jrsonnet-stdlib/src/arrays.rs
@@ -4,7 +4,7 @@
 	bail,
 	function::{builtin, FuncVal, NativeFn},
 	runtime_error,
-	typed::{BoundedI32, BoundedUsize, Either2, Typed},
+	typed::{BoundedI32, BoundedUsize, Either2, FromUntyped},
 	val::{equals, ArrValue, IndexableVal},
 	Either, IStr, ObjValue, ObjValueBuilder, Result, ResultExt, Thunk, Val,
 };
@@ -24,7 +24,7 @@
 	}
 	func.evaluate_trivial().map_or_else(
 		// TODO: Different mapped array impl avoiding allocating unnecessary vals
-		|| Ok(ArrValue::range_exclusive(0, *sz).map(Typed::from_untyped(Val::Func(func))?)),
+		|| Ok(ArrValue::range_exclusive(0, *sz).map(FromUntyped::from_untyped(Val::Func(func))?)),
 		|trivial| {
 			let mut out = Vec::with_capacity(*sz as usize);
 			for _ in 0..*sz {
modifiedcrates/jrsonnet-stdlib/src/keyf.rsdiffbeforeafterboth
--- a/crates/jrsonnet-stdlib/src/keyf.rs
+++ b/crates/jrsonnet-stdlib/src/keyf.rs
@@ -1,5 +1,5 @@
 use jrsonnet_evaluator::function::{CallLocation, FuncVal, PreparedFuncVal};
-use jrsonnet_evaluator::typed::{ComplexValType, Typed, ValType};
+use jrsonnet_evaluator::typed::{ComplexValType, FromUntyped, Typed, ValType};
 use jrsonnet_evaluator::{Error, Result, Thunk, Val};
 
 #[derive(Default, Clone)]
@@ -31,11 +31,9 @@
 
 impl Typed for KeyF {
 	const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Func);
+}
+impl FromUntyped for KeyF {
 	fn from_untyped(untyped: Val) -> Result<Self> {
 		FuncVal::from_untyped(untyped).map(Self::new)
-	}
-
-	fn into_untyped(_typed: Self) -> Result<Val> {
-		unreachable!("unused, todo: port split of Typed trait from #193")
 	}
 }
modifiedcrates/jrsonnet-stdlib/src/manifest/ini.rsdiffbeforeafterboth
--- a/crates/jrsonnet-stdlib/src/manifest/ini.rs
+++ b/crates/jrsonnet-stdlib/src/manifest/ini.rs
@@ -2,7 +2,7 @@
 
 use jrsonnet_evaluator::{
 	manifest::{ManifestFormat, ToStringFormat},
-	typed::Typed,
+	typed::{FromUntyped, Typed},
 	ObjValue, Result, ResultExt, Val,
 };
 use jrsonnet_parser::IStr;
modifiedcrates/jrsonnet-stdlib/src/manifest/xml.rsdiffbeforeafterboth
--- a/crates/jrsonnet-stdlib/src/manifest/xml.rs
+++ b/crates/jrsonnet-stdlib/src/manifest/xml.rs
@@ -1,7 +1,7 @@
 use jrsonnet_evaluator::{
 	bail, in_description_frame,
 	manifest::{ManifestFormat, ToStringFormat},
-	typed::{ComplexValType, Either2, Typed, ValType},
+	typed::{ComplexValType, Either2, FromUntyped, Typed, ValType},
 	val::ArrValue,
 	Either, ObjValue, Result, ResultExt, Val,
 };
@@ -32,11 +32,8 @@
 }
 impl Typed for JSONMLValue {
 	const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Arr);
-
-	fn into_untyped(_typed: Self) -> Result<Val> {
-		unreachable!("not used, reserved for parseXML?")
-	}
-
+}
+impl FromUntyped for JSONMLValue {
 	fn from_untyped(untyped: Val) -> Result<Self> {
 		let val = <Either![ArrValue, String]>::from_untyped(untyped)
 			.description("parsing JSONML value (an array or string)")?;
@@ -73,7 +70,7 @@
 			children: in_description_frame(
 				|| "parsing children".to_owned(),
 				|| {
-					Typed::from_untyped(Val::Arr(arr.slice(
+					FromUntyped::from_untyped(Val::Arr(arr.slice(
 						Some(if has_attrs { 2 } else { 1 }),
 						None,
 						None,
modifiedcrates/jrsonnet-stdlib/src/strings.rsdiffbeforeafterboth
--- a/crates/jrsonnet-stdlib/src/strings.rs
+++ b/crates/jrsonnet-stdlib/src/strings.rs
@@ -4,7 +4,7 @@
 	bail,
 	error::{ErrorKind::*, Result},
 	function::builtin,
-	typed::{Either2, Typed, M1},
+	typed::{Either2, FromUntyped, M1},
 	val::{ArrValue, IndexableVal},
 	Either, IStr, Val,
 };
modifiedtests/tests/builtin.rsdiffbeforeafterboth
--- a/tests/tests/builtin.rs
+++ b/tests/tests/builtin.rs
@@ -5,7 +5,7 @@
 	function::{CallLocation, FuncVal, builtin, builtin::Builtin},
 	parser::Source,
 	trace::PathResolver,
-	typed::Typed,
+	typed::FromUntyped,
 };
 use jrsonnet_gcmodule::Trace;
 use jrsonnet_stdlib::ContextInitializer as StdContextInitializer;
modifiedtests/tests/typed_obj.rsdiffbeforeafterboth
--- a/tests/tests/typed_obj.rs
+++ b/tests/tests/typed_obj.rs
@@ -2,7 +2,11 @@
 
 use std::fmt::Debug;
 
-use jrsonnet_evaluator::{Result, State, trace::PathResolver, typed::Typed};
+use jrsonnet_evaluator::{
+	Result, State,
+	trace::PathResolver,
+	typed::{FromUntyped, IntoUntyped, Typed},
+};
 use jrsonnet_stdlib::ContextInitializer;
 
 #[derive(Clone, Typed, PartialEq, Debug)]
@@ -11,7 +15,9 @@
 	b: u16,
 }
 
-fn test_roundtrip<T: Typed + PartialEq + Debug + Clone>(value: T) -> Result<()> {
+fn test_roundtrip<T: Typed + PartialEq + Debug + Clone + FromUntyped + IntoUntyped>(
+	value: T,
+) -> Result<()> {
 	let untyped = T::into_untyped(value.clone())?;
 	let value2 = T::from_untyped(untyped.clone())?;
 	ensure_eq!(value, value2);