git.delta.rocks / jrsonnet / refs/commits / 1bfba233fc03

1use std::{collections::BTreeMap, marker::PhantomData, ops::Deref};23use jrsonnet_gcmodule::Trace;4use jrsonnet_interner::{IBytes, IStr};5use jrsonnet_types::{ComplexValType, ValType};67use crate::{8	ObjValue, ObjValueBuilder, Result, ResultExt, Thunk, Val,9	arr::{ArrValue, BytesArray},10	bail,11	function::FuncVal,12	typed::CheckType,13	val::{IndexableVal, NumValue, StrValue, ThunkMapper},14};1516#[doc(hidden)]17pub mod __typed_macro_prelude {18	pub use ::jrsonnet_evaluator::{19		IStr, ObjValue, ObjValueBuilder, State, Val,20		error::{ErrorKind, Result as JrResult},21		typed::{22			CheckType, ComplexValType, FromUntyped, IntoUntyped, ParseTypedObj, SerializeTypedObj,23			Typed,24		},25	};26}27pub use jrsonnet_macros::{FromUntyped, IntoUntyped, Typed};2829#[derive(Trace)]30struct ThunkFromUntyped<K: Trace>(PhantomData<fn() -> K>);31impl<K> ThunkMapper<Val> for ThunkFromUntyped<K>32where33	K: Typed + FromUntyped + Trace,34{35	type Output = K;3637	fn map(self, from: Val) -> Result<Self::Output> {38		K::from_untyped(from)39	}40}41impl<K: Trace> Default for ThunkFromUntyped<K> {42	fn default() -> Self {43		Self(PhantomData)44	}45}46#[derive(Trace)]47struct ThunkIntoUntyped<K: Trace>(PhantomData<fn() -> K>);48impl<K> ThunkMapper<K> for ThunkIntoUntyped<K>49where50	K: Typed + Trace + IntoUntyped,51{52	type Output = Val;5354	fn map(self, from: K) -> Result<Self::Output> {55		K::into_untyped(from)56	}57}58impl<K: Trace> Default for ThunkIntoUntyped<K> {59	fn default() -> Self {60		Self(PhantomData)61	}62}6364#[diagnostic::on_unimplemented(65	note = "don't implement `ParseTypedObj` directly, it is automatically provided by `FromUntyped` derive"66)]67pub trait ParseTypedObj: Typed {68	fn parse(obj: &ObjValue) -> Result<Self>;69}7071#[diagnostic::on_unimplemented(72	note = "don't implement `SerializeTypedObj` directly, it is automatically provided by `IntoUntyped` derive"73)]74pub trait SerializeTypedObj: Typed {75	fn serialize(self, out: &mut ObjValueBuilder) -> Result<()>;76	fn into_object(self) -> Result<ObjValue> {77		let mut builder = ObjValueBuilder::new();78		self.serialize(&mut builder)?;79		Ok(builder.build())80	}81}8283pub trait Typed: Sized {84	const TYPE: &'static ComplexValType;85}86pub trait IntoUntyped: Typed {87	// Whatever caller should use `into_lazy_untyped` instead of `into_untyped`88	fn provides_lazy() -> bool {89		false90	}91	fn into_untyped(typed: Self) -> Result<Val>;92	fn into_lazy_untyped(typed: Self) -> Thunk<Val> {93		Thunk::from(Self::into_untyped(typed))94	}95}96pub trait IntoUntypedResult: Typed {97	/// Hack to make builtins be able to return non-result values, and make macros able to convert those values to result98	/// This method returns identity in impl Typed for Result, and should not be overriden99	#[doc(hidden)]100	fn into_untyped_result(typed: Self) -> Result<Val>;101}102impl<T> IntoUntypedResult for T103where104	T: IntoUntyped,105{106	fn into_untyped_result(typed: Self) -> Result<Val> {107		T::into_untyped(typed)108	}109}110111pub trait FromUntyped: Typed {112	fn from_untyped(untyped: Val) -> Result<Self>;113	fn from_lazy_untyped(lazy: Thunk<Val>) -> Result<Self> {114		Self::from_untyped(lazy.evaluate()?)115	}116117	// Whatever caller should use `from_lazy_untyped` instead of `from_untyped` when possible118	fn wants_lazy() -> bool {119		false120	}121}122123impl<T> Typed for Thunk<T>124where125	T: Typed + Trace + Clone,126{127	const TYPE: &'static ComplexValType = &ComplexValType::Lazy(T::TYPE);128}129130impl IntoUntyped for Thunk<Val> {131	fn into_untyped(typed: Self) -> Result<Val> {132		typed.evaluate()133	}134	fn provides_lazy() -> bool {135		true136	}137138	fn into_lazy_untyped(inner: Self) -> Thunk<Val> {139		inner140	}141}142143impl<T> FromUntyped for Thunk<T>144where145	T: Typed + FromUntyped + Trace + Clone,146{147	fn from_untyped(untyped: Val) -> Result<Self> {148		Self::from_lazy_untyped(Thunk::evaluated(untyped))149	}150151	fn wants_lazy() -> bool {152		true153	}154155	fn from_lazy_untyped(inner: Thunk<Val>) -> Result<Self> {156		Ok(inner.map(<ThunkFromUntyped<T>>::default()))157	}158}159160pub const MAX_SAFE_INTEGER: f64 = ((1u64 << (f64::MANTISSA_DIGITS)) - 1) as f64;161pub const MIN_SAFE_INTEGER: f64 = (-((1i64 << (f64::MANTISSA_DIGITS)) - 1)) as f64;162163macro_rules! impl_int {164	($($ty:ty)*) => {$(165		impl Typed for $ty {166			const TYPE: &'static ComplexValType =167				&ComplexValType::BoundedNumber(Some(Self::MIN as f64), Some(Self::MAX as f64));168		}169		impl FromUntyped for $ty {170			fn from_untyped(value: Val) -> Result<Self> {171				<Self as Typed>::TYPE.check(&value)?;172				match value {173					Val::Num(n) => {174						let n = n.get();175						#[allow(clippy::float_cmp)]176						if n.trunc() != n {177							bail!(178								"cannot convert number with fractional part to {}",179								stringify!($ty)180							)181						}182						Ok(n as Self)183					}184					_ => unreachable!(),185				}186			}187		}188		impl IntoUntyped for $ty {189			fn into_untyped(value: Self) -> Result<Val> {190				Ok(Val::Num(value.into()))191			}192		}193	)*};194}195196impl_int!(i8 u8 i16 u16 i32 u32);197198macro_rules! impl_bounded_int {199	($($name:ident = $ty:ty)*) => {$(200		#[derive(Clone, Copy)]201		pub struct $name<const MIN: $ty, const MAX: $ty>($ty);202		impl<const MIN: $ty, const MAX: $ty> $name<MIN, MAX> {203			pub const fn new(value: $ty) -> Option<$name<MIN, MAX>> {204				if value >= MIN && value <= MAX {205					Some(Self(value))206				} else {207					None208				}209			}210			pub const fn value(self) -> $ty {211				self.0212			}213		}214		impl<const MIN: $ty, const MAX: $ty> Deref for $name<MIN, MAX> {215			type Target = $ty;216			fn deref(&self) -> &Self::Target {217				&self.0218			}219		}220221		impl<const MIN: $ty, const MAX: $ty> Typed for $name<MIN, MAX> {222			const TYPE: &'static ComplexValType =223				&ComplexValType::BoundedNumber(224					Some(MIN as f64),225					Some(MAX as f64),226				);227		}228229		impl<const MIN: $ty, const MAX: $ty> FromUntyped for $name<MIN, MAX> {230			fn from_untyped(value: Val) -> Result<Self> {231				<Self as Typed>::TYPE.check(&value)?;232				match value {233					Val::Num(n) => {234						let n = n.get();235						#[allow(clippy::float_cmp)]236						if n.trunc() != n {237							bail!(238								"cannot convert number with fractional part to {}",239								stringify!($ty)240							)241						}242						Ok(Self(n as $ty))243					}244					_ => unreachable!(),245				}246			}247		}248249		impl<const MIN: $ty, const MAX: $ty> IntoUntyped for $name<MIN, MAX> {250			#[allow(clippy::cast_lossless)]251			fn into_untyped(value: Self) -> Result<Val> {252				Ok(Val::try_num(value.0)?)253			}254		}255	)*};256}257258impl_bounded_int!(259	BoundedI8 = i8260	BoundedI16 = i16261	BoundedI32 = i32262	BoundedI64 = i64263	BoundedUsize = usize264);265266impl Typed for f64 {267	const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Num);268}269impl IntoUntyped for f64 {270	fn into_untyped(value: Self) -> Result<Val> {271		Ok(Val::try_num(value)?)272	}273}274impl FromUntyped for f64 {275	fn from_untyped(value: Val) -> Result<Self> {276		<Self as Typed>::TYPE.check(&value)?;277		match value {278			Val::Num(n) => Ok(n.get()),279			_ => unreachable!(),280		}281	}282}283284pub struct PositiveF64(pub f64);285impl Typed for PositiveF64 {286	const TYPE: &'static ComplexValType = &ComplexValType::BoundedNumber(Some(0.0), None);287}288impl IntoUntyped for PositiveF64 {289	fn into_untyped(value: Self) -> Result<Val> {290		Ok(Val::try_num(value.0)?)291	}292}293impl FromUntyped for PositiveF64 {294	fn from_untyped(value: Val) -> Result<Self> {295		<Self as Typed>::TYPE.check(&value)?;296		match value {297			Val::Num(n) => Ok(Self(n.get())),298			_ => unreachable!(),299		}300	}301}302impl Typed for usize {303	const TYPE: &'static ComplexValType =304		&ComplexValType::BoundedNumber(Some(0.0), Some(MAX_SAFE_INTEGER));305}306impl IntoUntyped for usize {307	fn into_untyped(value: Self) -> Result<Val> {308		Ok(Val::try_num(value)?)309	}310}311impl FromUntyped for usize {312	fn from_untyped(value: Val) -> Result<Self> {313		<Self as Typed>::TYPE.check(&value)?;314		match value {315			Val::Num(n) => {316				let n = n.get();317				#[allow(clippy::float_cmp)]318				if n.trunc() != n {319					bail!("cannot convert number with fractional part to usize")320				}321				Ok(n as Self)322			}323			_ => unreachable!(),324		}325	}326}327328impl Typed for IStr {329	const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Str);330}331impl IntoUntyped for IStr {332	fn into_untyped(value: Self) -> Result<Val> {333		Ok(Val::string(value))334	}335}336impl FromUntyped for IStr {337	fn from_untyped(value: Val) -> Result<Self> {338		<Self as Typed>::TYPE.check(&value)?;339		match value {340			Val::Str(s) => Ok(s.into_flat()),341			_ => unreachable!(),342		}343	}344}345346impl Typed for String {347	const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Str);348}349impl IntoUntyped for String {350	fn into_untyped(value: Self) -> Result<Val> {351		Ok(Val::string(value))352	}353}354impl FromUntyped for String {355	fn from_untyped(value: Val) -> Result<Self> {356		<Self as Typed>::TYPE.check(&value)?;357		match value {358			Val::Str(s) => Ok(s.to_string()),359			_ => unreachable!(),360		}361	}362}363364impl Typed for StrValue {365	const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Str);366}367impl IntoUntyped for StrValue {368	fn into_untyped(value: Self) -> Result<Val> {369		Ok(Val::Str(value))370	}371}372impl FromUntyped for StrValue {373	fn from_untyped(value: Val) -> Result<Self> {374		<Self as Typed>::TYPE.check(&value)?;375		match value {376			Val::Str(s) => Ok(s),377			_ => unreachable!(),378		}379	}380}381382impl Typed for char {383	const TYPE: &'static ComplexValType = &ComplexValType::Char;384}385impl IntoUntyped for char {386	fn into_untyped(value: Self) -> Result<Val> {387		Ok(Val::string(value))388	}389}390impl FromUntyped for char {391	fn from_untyped(value: Val) -> Result<Self> {392		<Self as Typed>::TYPE.check(&value)?;393		match value {394			Val::Str(s) => Ok(s.into_flat().chars().next().unwrap()),395			_ => unreachable!(),396		}397	}398}399400// TODO: View into vec using ArrayLike?401impl<T> Typed for Vec<T>402where403	T: Typed,404{405	const TYPE: &'static ComplexValType = &ComplexValType::ArrayRef(T::TYPE);406}407impl<T: Typed + IntoUntyped> IntoUntyped for Vec<T> {408	fn into_untyped(value: Self) -> Result<Val> {409		Ok(Val::Arr(410			value411				.into_iter()412				.map(T::into_untyped)413				.collect::<Result<ArrValue>>()?,414		))415	}416}417impl<T: Typed + FromUntyped> FromUntyped for Vec<T> {418	fn from_untyped(value: Val) -> Result<Self> {419		let Val::Arr(a) = value else {420			<Self as Typed>::TYPE.check(&value)?;421			unreachable!("typecheck should fail")422		};423		a.iter()424			.enumerate()425			.map(|(i, r)| {426				r.and_then(|t| {427					T::from_untyped(t).with_description(|| format!("parsing elem <{i}>"))428				})429			})430			.collect::<Result<Self>>()431	}432}433434// TODO: View into BTreeMap using ObjectCore?435impl<K, V> Typed for BTreeMap<K, V>436where437	K: Typed + Ord,438	V: Typed,439{440	const TYPE: &'static ComplexValType = &ComplexValType::AttrsOf(V::TYPE);441}442impl<K, V> IntoUntyped for BTreeMap<K, V>443where444	K: Typed + Ord + IntoUntyped,445	V: Typed + IntoUntyped,446{447	fn into_untyped(typed: Self) -> Result<Val> {448		let mut out = ObjValueBuilder::with_capacity(typed.len());449		for (k, v) in typed {450			let Some(key) = K::into_untyped(k)?.as_str() else {451				bail!("map key should serialize to string");452			};453			let value = V::into_untyped(v)?;454			out.field(key).value(value);455		}456		Ok(Val::Obj(out.build()))457	}458}459impl<K, V> FromUntyped for BTreeMap<K, V>460where461	K: FromUntyped + Ord,462	V: FromUntyped,463{464	fn from_untyped(value: Val) -> Result<Self> {465		Self::TYPE.check(&value)?;466		let obj = value.as_obj().expect("typecheck should fail");467468		let mut out = Self::new();469		if V::wants_lazy() {470			for key in obj.fields_ex(471				false,472				#[cfg(feature = "exp-preserve-order")]473				false,474			) {475				let value = obj.get_lazy(key.clone()).expect("field exists");476				let value = V::from_lazy_untyped(value)?;477				let key = K::from_untyped(Val::Str(key.into()))?;478				let _ = out.insert(key, value);479			}480		} else {481			for (key, value) in obj.iter(482				#[cfg(feature = "exp-preserve-order")]483				false,484			) {485				let key = K::from_untyped(Val::Str(key.into()))?;486				let value = V::from_untyped(value?)?;487				let _ = out.insert(key, value);488			}489		}490		Ok(out)491	}492}493494impl Typed for Val {495	const TYPE: &'static ComplexValType = &ComplexValType::Any;496}497impl IntoUntyped for Val {498	fn into_untyped(typed: Self) -> Result<Val> {499		Ok(typed)500	}501}502impl FromUntyped for Val {503	fn from_untyped(untyped: Val) -> Result<Self> {504		Ok(untyped)505	}506}507508#[doc(hidden)]509impl<T> Typed for Result<T>510where511	T: Typed,512{513	const TYPE: &'static ComplexValType = &ComplexValType::Any;514}515impl<T: IntoUntyped> IntoUntypedResult for Result<T> {516	fn into_untyped_result(typed: Self) -> Result<Val> {517		typed.map(T::into_untyped)?518	}519}520521/// Specialization522impl Typed for IBytes {523	const TYPE: &'static ComplexValType =524		&ComplexValType::ArrayRef(&ComplexValType::BoundedNumber(Some(0.0), Some(255.0)));525}526impl IntoUntyped for IBytes {527	fn into_untyped(value: Self) -> Result<Val> {528		Ok(Val::Arr(ArrValue::bytes(value)))529	}530}531impl FromUntyped for IBytes {532	fn from_untyped(value: Val) -> Result<Self> {533		let Val::Arr(a) = &value else {534			<Self as Typed>::TYPE.check(&value)?;535			unreachable!()536		};537		if let Some(bytes) = a.as_any().downcast_ref::<BytesArray>() {538			return Ok(bytes.0.as_slice().into());539		}540		<Self as Typed>::TYPE.check(&value)?;541		// Any::downcast_ref::<ByteArray>(&a);542		let mut out = Vec::with_capacity(a.len());543		for e in a.iter() {544			let r = e?;545			out.push(u8::from_untyped(r)?);546		}547		Ok(out.as_slice().into())548	}549}550551pub struct M1;552impl Typed for M1 {553	const TYPE: &'static ComplexValType = &ComplexValType::BoundedNumber(Some(-1.0), Some(-1.0));554}555impl IntoUntyped for M1 {556	fn into_untyped(_: Self) -> Result<Val> {557		Ok(Val::Num(NumValue::new(-1.0).expect("finite")))558	}559}560impl FromUntyped for M1 {561	fn from_untyped(value: Val) -> Result<Self> {562		<Self as Typed>::TYPE.check(&value)?;563		Ok(Self)564	}565}566567macro_rules! decl_either {568	($($name: ident, $($id: ident)*);*) => {$(569		#[derive(Clone)]570		pub enum $name<$($id),*> {571			$($id($id)),*572		}573		impl<$($id),*> Typed for $name<$($id),*>574		where575			$($id: Typed,)*576		{577			const TYPE: &'static ComplexValType = &ComplexValType::UnionRef(&[$($id::TYPE),*]);578		}579		impl<$($id),*> IntoUntyped for $name<$($id),*>580		where581			$($id: Typed + IntoUntyped,)*582		{583			fn into_untyped(value: Self) -> Result<Val> {584				match value {$(585					$name::$id(v) => $id::into_untyped(v)586				),*}587			}588		}589590		impl<$($id),*> FromUntyped for $name<$($id),*>591		where592			$($id: Typed + FromUntyped,)*593		{594			fn from_untyped(value: Val) -> Result<Self> {595				$(596					if $id::TYPE.check(&value).is_ok() {597						$id::from_untyped(value).map(Self::$id)598					} else599				)* {600					<Self as Typed>::TYPE.check(&value)?;601					unreachable!()602				}603			}604		}605	)*}606}607decl_either!(608	Either1, A;609	Either2, A B;610	Either3, A B C;611	Either4, A B C D;612	Either5, A B C D E;613	Either6, A B C D E F;614	Either7, A B C D E F G615);616#[macro_export]617macro_rules! Either {618	($a:ty) => {$crate::typed::Either1<$a>};619	($a:ty, $b:ty) => {$crate::typed::Either2<$a, $b>};620	($a:ty, $b:ty, $c:ty) => {$crate::typed::Either3<$a, $b, $c>};621	($a:ty, $b:ty, $c:ty, $d:ty) => {$crate::typed::Either4<$a, $b, $c, $d>};622	($a:ty, $b:ty, $c:ty, $d:ty, $e:ty) => {$crate::typed::Either5<$a, $b, $c, $d, $e>};623	($a:ty, $b:ty, $c:ty, $d:ty, $e:ty, $f:ty) => {$crate::typed::Either6<$a, $b, $c, $d, $e, $f>};624	($a:ty, $b:ty, $c:ty, $d:ty, $e:ty, $f:ty, $g:ty) => {$crate::typed::Either7<$a, $b, $c, $d, $e, $f, $g>};625}626pub use Either;627628pub type MyType = Either![u32, f64, String];629630impl Typed for ArrValue {631	const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Arr);632}633impl IntoUntyped for ArrValue {634	fn into_untyped(value: Self) -> Result<Val> {635		Ok(Val::Arr(value))636	}637}638impl FromUntyped for ArrValue {639	fn from_untyped(value: Val) -> Result<Self> {640		<Self as Typed>::TYPE.check(&value)?;641		match value {642			Val::Arr(a) => Ok(a),643			_ => unreachable!(),644		}645	}646}647648impl Typed for FuncVal {649	const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Func);650}651impl IntoUntyped for FuncVal {652	fn into_untyped(value: Self) -> Result<Val> {653		Ok(Val::Func(value))654	}655}656impl FromUntyped for FuncVal {657	fn from_untyped(value: Val) -> Result<Self> {658		<Self as Typed>::TYPE.check(&value)?;659		match value {660			Val::Func(a) => Ok(a),661			_ => unreachable!(),662		}663	}664}665666impl Typed for ObjValue {667	const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Obj);668}669impl IntoUntyped for ObjValue {670	fn into_untyped(value: Self) -> Result<Val> {671		Ok(Val::Obj(value))672	}673}674impl FromUntyped for ObjValue {675	fn from_untyped(value: Val) -> Result<Self> {676		<Self as Typed>::TYPE.check(&value)?;677		match value {678			Val::Obj(a) => Ok(a),679			_ => unreachable!(),680		}681	}682}683684impl Typed for bool {685	const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Bool);686}687impl IntoUntyped for bool {688	fn into_untyped(value: Self) -> Result<Val> {689		Ok(Val::Bool(value))690	}691}692impl FromUntyped for bool {693	fn from_untyped(value: Val) -> Result<Self> {694		<Self as Typed>::TYPE.check(&value)?;695		match value {696			Val::Bool(a) => Ok(a),697			_ => unreachable!(),698		}699	}700}701702impl Typed for IndexableVal {703	const TYPE: &'static ComplexValType = &ComplexValType::UnionRef(&[704		&ComplexValType::Simple(ValType::Arr),705		&ComplexValType::Simple(ValType::Str),706	]);707}708impl IntoUntyped for IndexableVal {709	fn into_untyped(value: Self) -> Result<Val> {710		match value {711			Self::Str(s) => Ok(Val::string(s)),712			Self::Arr(a) => Ok(Val::Arr(a)),713		}714	}715}716impl FromUntyped for IndexableVal {717	fn from_untyped(value: Val) -> Result<Self> {718		<Self as Typed>::TYPE.check(&value)?;719		value.into_indexable()720	}721}722723pub struct Null;724impl Typed for Null {725	const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Null);726}727impl IntoUntyped for Null {728	fn into_untyped(_: Self) -> Result<Val> {729		Ok(Val::Null)730	}731}732impl FromUntyped for Null {733	fn from_untyped(value: Val) -> Result<Self> {734		<Self as Typed>::TYPE.check(&value)?;735		Ok(Self)736	}737}738739impl<T> Typed for Option<T>740where741	T: Typed,742{743	const TYPE: &'static ComplexValType =744		&ComplexValType::UnionRef(&[&ComplexValType::Simple(ValType::Null), T::TYPE]);745}746impl<T> IntoUntyped for Option<T>747where748	T: Typed + IntoUntyped,749{750	fn into_untyped(typed: Self) -> Result<Val> {751		typed.map_or_else(|| Ok(Val::Null), |v| T::into_untyped(v))752	}753}754impl<T> FromUntyped for Option<T>755where756	T: Typed + FromUntyped,757{758	fn from_untyped(untyped: Val) -> Result<Self> {759		if matches!(untyped, Val::Null) {760			Ok(None)761		} else {762			T::from_untyped(untyped).map(Some)763		}764	}765}766767impl Typed for NumValue {768	const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Num);769}770impl IntoUntyped for NumValue {771	fn into_untyped(typed: Self) -> Result<Val> {772		Ok(Val::Num(typed))773	}774}775impl FromUntyped for NumValue {776	fn from_untyped(untyped: Val) -> Result<Self> {777		Self::TYPE.check(&untyped)?;778		match untyped {779			Val::Num(v) => Ok(v),780			_ => unreachable!(),781		}782	}783}