difftreelog
perf inline trivial IntoUntyped
in: master
1 file changed
crates/jrsonnet-evaluator/src/typed/conversions.rsdiffbeforeafterboth1use std::{any::TypeId, collections::BTreeMap, marker::PhantomData, mem::transmute, 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,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}86impl<T> Typed for &T87where88 T: Typed,89{90 const TYPE: &'static ComplexValType = <&T as Typed>::TYPE;91}92pub trait IntoUntyped: Typed {93 // Whatever caller should use `into_lazy_untyped` instead of `into_untyped`94 fn provides_lazy() -> bool {95 false96 }97 fn into_untyped(typed: Self) -> Result<Val>;98 fn into_lazy_untyped(typed: Self) -> Thunk<Val> {99 Thunk::from(Self::into_untyped(typed))100 }101}102103pub trait IntoUntypedResult: Typed {104 /// Hack to make builtins be able to return non-result values, and make macros able to convert those values to result105 /// This method returns identity in impl Typed for Result, and should not be overriden106 #[doc(hidden)]107 fn into_untyped_result(typed: Self) -> Result<Val>;108}109impl<T> IntoUntypedResult for T110where111 T: IntoUntyped,112{113 fn into_untyped_result(typed: Self) -> Result<Val> {114 T::into_untyped(typed)115 }116}117118pub trait FromUntyped: Typed {119 fn from_untyped(untyped: Val) -> Result<Self>;120 fn from_lazy_untyped(lazy: Thunk<Val>) -> Result<Self> {121 Self::from_untyped(lazy.evaluate()?)122 }123124 // Whatever caller should use `from_lazy_untyped` instead of `from_untyped` when possible125 fn wants_lazy() -> bool {126 false127 }128}129130impl<T> Typed for Thunk<T>131where132 T: Typed + Trace + Clone,133{134 const TYPE: &'static ComplexValType = &ComplexValType::Lazy(T::TYPE);135}136137#[inline]138fn try_cast_thunk_val<T: 'static>(typed: Thunk<T>) -> Result<Thunk<Val>, Thunk<T>> {139 if TypeId::of::<T>() == TypeId::of::<Val>() {140 // SAFETY: We know that it is exactly the same type, and we discard the original after that141 // to avoid double-free.142 let transmuted = unsafe { transmute::<Thunk<T>, Thunk<Val>>(typed) };143 Ok(transmuted)144 } else {145 Err(typed)146 }147}148impl<T> IntoUntyped for Thunk<T>149where150 T: IntoUntyped + Trace + Clone,151{152 #[inline]153 fn into_untyped(typed: Self) -> Result<Val> {154 T::into_untyped(typed.evaluate()?)155 }156 fn provides_lazy() -> bool {157 true158 }159160 fn into_lazy_untyped(inner: Self) -> Thunk<Val> {161 // Avoid lazy mapping162 let inner = match try_cast_thunk_val(inner) {163 Ok(v) => return v,164 Err(e) => e,165 };166 inner.map(<ThunkIntoUntyped<T>>::default())167 }168}169impl<T> IntoUntyped for &Thunk<T>170where171 T: IntoUntyped + Trace + Clone,172{173 fn into_untyped(typed: Self) -> Result<Val> {174 T::into_untyped(typed.evaluate()?)175 }176 fn provides_lazy() -> bool {177 true178 }179180 fn into_lazy_untyped(inner: Self) -> Thunk<Val> {181 // Avoid lazy mapping182 let inner = match try_cast_thunk_val(inner.clone()) {183 Ok(v) => return v,184 Err(e) => e,185 };186 inner.map(<ThunkIntoUntyped<T>>::default())187 }188}189190#[inline]191fn try_cast_thunk_t<T: 'static>(typed: Thunk<Val>) -> Result<Thunk<T>, Thunk<Val>> {192 if TypeId::of::<T>() == TypeId::of::<Val>() {193 // SAFETY: We know that it is exactly the same type, and we discard the original after that194 // to avoid double-free.195 let transmuted = unsafe { transmute::<Thunk<Val>, Thunk<T>>(typed) };196 Ok(transmuted)197 } else {198 Err(typed)199 }200}201impl<T> FromUntyped for Thunk<T>202where203 T: Typed + FromUntyped + Trace + Clone,204{205 fn from_untyped(untyped: Val) -> Result<Self> {206 Self::from_lazy_untyped(Thunk::evaluated(untyped))207 }208209 fn wants_lazy() -> bool {210 true211 }212213 fn from_lazy_untyped(inner: Thunk<Val>) -> Result<Self> {214 // Avoid lazy mapping215 let inner = match try_cast_thunk_t(inner) {216 Ok(v) => return Ok(v),217 Err(e) => e,218 };219 Ok(inner.map(<ThunkFromUntyped<T>>::default()))220 }221}222223#[expect(clippy::cast_precision_loss, reason = "checked to not overflow")]224pub const MAX_SAFE_INTEGER: f64 = ((1u64 << (f64::MANTISSA_DIGITS)) - 1) as f64;225#[expect(clippy::cast_precision_loss, reason = "checked to not overflow")]226pub const MIN_SAFE_INTEGER: f64 = (-((1i64 << (f64::MANTISSA_DIGITS)) - 1)) as f64;227228macro_rules! impl_int {229 ($($ty:ty)*) => {$(230 impl Typed for $ty {231 const TYPE: &'static ComplexValType =232 &ComplexValType::BoundedNumber(Some(Self::MIN as f64), Some(Self::MAX as f64));233 }234 impl FromUntyped for $ty {235 fn from_untyped(value: Val) -> Result<Self> {236 <Self as Typed>::TYPE.check(&value)?;237 match value {238 Val::Num(n) => {239 let n = n.get();240 #[allow(clippy::float_cmp)]241 if n.trunc() != n {242 bail!(243 "cannot convert number with fractional part to {}",244 stringify!($ty)245 )246 }247 #[allow(clippy::cast_sign_loss, clippy::cast_possible_truncation, reason = "checked by TYPE")]248 Ok(n as Self)249 }250 _ => unreachable!(),251 }252 }253 }254 impl IntoUntyped for &$ty {255 fn into_untyped(value: Self) -> Result<Val> {256 Ok(Val::Num((*value).into()))257 }258 }259 impl IntoUntyped for $ty {260 fn into_untyped(value: Self) -> Result<Val> {261 Ok(Val::Num(value.into()))262 }263 }264 )*};265}266267impl_int!(i8 u8 i16 u16 i32 u32);268269macro_rules! impl_bounded_int {270 ($($name:ident = $ty:ty)*) => {$(271 #[derive(Clone, Copy)]272 #[allow(clippy::cast_possible_truncation, reason = "overflow is api misuse")]273 pub struct $name<const MIN: $ty, const MAX: $ty>($ty);274 impl<const MIN: $ty, const MAX: $ty> $name<MIN, MAX> {275 pub const fn new(value: $ty) -> Option<$name<MIN, MAX>> {276 if value >= MIN && value <= MAX {277 Some(Self(value))278 } else {279 None280 }281 }282 pub const fn value(self) -> $ty {283 self.0284 }285 }286 impl<const MIN: $ty, const MAX: $ty> Deref for $name<MIN, MAX> {287 type Target = $ty;288 fn deref(&self) -> &Self::Target {289 &self.0290 }291 }292293 impl<const MIN: $ty, const MAX: $ty> Typed for $name<MIN, MAX> {294 #[allow(clippy::cast_possible_truncation, clippy::cast_precision_loss, reason = "overflow is api misuse")]295 const TYPE: &'static ComplexValType =296 &ComplexValType::BoundedNumber(297 Some(MIN as f64),298 Some(MAX as f64),299 );300 }301302 impl<const MIN: $ty, const MAX: $ty> FromUntyped for $name<MIN, MAX> {303 fn from_untyped(value: Val) -> Result<Self> {304 <Self as Typed>::TYPE.check(&value)?;305 match value {306 Val::Num(n) => {307 let n = n.get();308 #[allow(clippy::float_cmp)]309 if n.trunc() != n {310 bail!(311 "cannot convert number with fractional part to {}",312 stringify!($ty)313 )314 }315 #[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss, reason = "overflow is api misuse, the range is checked by TYPE")]316 Ok(Self(n as $ty))317 }318 _ => unreachable!(),319 }320 }321 }322323 impl<const MIN: $ty, const MAX: $ty> IntoUntyped for $name<MIN, MAX> {324 #[allow(clippy::cast_lossless)]325 fn into_untyped(value: Self) -> Result<Val> {326 Ok(Val::try_num(value.0)?)327 }328 }329 )*};330}331332impl_bounded_int!(333 BoundedI8 = i8334 BoundedI16 = i16335 BoundedI32 = i32336 BoundedI64 = i64337 BoundedUsize = usize338);339340impl Typed for f64 {341 const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Num);342}343impl IntoUntyped for &f64 {344 fn into_untyped(value: Self) -> Result<Val> {345 Ok(Val::try_num(*value)?)346 }347}348impl IntoUntyped for f64 {349 fn into_untyped(value: Self) -> Result<Val> {350 Ok(Val::try_num(value)?)351 }352}353impl FromUntyped for f64 {354 fn from_untyped(value: Val) -> Result<Self> {355 <Self as Typed>::TYPE.check(&value)?;356 match value {357 Val::Num(n) => Ok(n.get()),358 _ => unreachable!(),359 }360 }361}362363pub struct PositiveF64(pub f64);364impl Typed for PositiveF64 {365 const TYPE: &'static ComplexValType = &ComplexValType::BoundedNumber(Some(0.0), None);366}367impl IntoUntyped for &PositiveF64 {368 fn into_untyped(value: Self) -> Result<Val> {369 Ok(Val::try_num(value.0)?)370 }371}372impl FromUntyped for PositiveF64 {373 fn from_untyped(value: Val) -> Result<Self> {374 <Self as Typed>::TYPE.check(&value)?;375 match value {376 Val::Num(n) => Ok(Self(n.get())),377 _ => unreachable!(),378 }379 }380}381impl Typed for usize {382 const TYPE: &'static ComplexValType =383 &ComplexValType::BoundedNumber(Some(0.0), Some(MAX_SAFE_INTEGER));384}385impl IntoUntyped for usize {386 fn into_untyped(value: Self) -> Result<Val> {387 Ok(Val::try_num(value)?)388 }389}390impl FromUntyped for usize {391 fn from_untyped(value: Val) -> Result<Self> {392 <Self as Typed>::TYPE.check(&value)?;393 match value {394 Val::Num(n) => {395 let n = n.get();396 #[allow(clippy::float_cmp)]397 if n.trunc() != n {398 bail!("cannot convert number with fractional part to usize")399 }400 #[allow(401 clippy::cast_possible_truncation,402 clippy::cast_sign_loss,403 reason = "the range is checked by TYPE"404 )]405 Ok(n as Self)406 }407 _ => unreachable!(),408 }409 }410}411412impl Typed for IStr {413 const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Str);414}415impl IntoUntyped for IStr {416 fn into_untyped(value: Self) -> Result<Val> {417 Ok(Val::string(value))418 }419}420impl FromUntyped for IStr {421 fn from_untyped(value: Val) -> Result<Self> {422 <Self as Typed>::TYPE.check(&value)?;423 match value {424 Val::Str(s) => Ok(s.into_flat()),425 _ => unreachable!(),426 }427 }428}429430impl Typed for String {431 const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Str);432}433impl IntoUntyped for String {434 fn into_untyped(value: Self) -> Result<Val> {435 Ok(Val::string(value))436 }437}438impl FromUntyped for String {439 fn from_untyped(value: Val) -> Result<Self> {440 <Self as Typed>::TYPE.check(&value)?;441 match value {442 Val::Str(s) => Ok(s.to_string()),443 _ => unreachable!(),444 }445 }446}447448impl Typed for StrValue {449 const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Str);450}451impl IntoUntyped for StrValue {452 fn into_untyped(value: Self) -> Result<Val> {453 Ok(Val::Str(value))454 }455}456impl FromUntyped for StrValue {457 fn from_untyped(value: Val) -> Result<Self> {458 <Self as Typed>::TYPE.check(&value)?;459 match value {460 Val::Str(s) => Ok(s),461 _ => unreachable!(),462 }463 }464}465466impl Typed for char {467 const TYPE: &'static ComplexValType = &ComplexValType::Char;468}469impl IntoUntyped for &char {470 fn into_untyped(value: Self) -> Result<Val> {471 Ok(Val::string(*value))472 }473}474impl IntoUntyped for char {475 fn into_untyped(value: Self) -> Result<Val> {476 Ok(Val::string(value))477 }478}479impl FromUntyped for char {480 fn from_untyped(value: Val) -> Result<Self> {481 <Self as Typed>::TYPE.check(&value)?;482 match value {483 Val::Str(s) => Ok(s.into_flat().chars().next().unwrap()),484 _ => unreachable!(),485 }486 }487}488489// TODO: View into vec using ArrayLike?490impl<T> Typed for Vec<T>491where492 T: Typed,493{494 const TYPE: &'static ComplexValType = &ComplexValType::ArrayRef(T::TYPE);495}496impl<T: Typed + IntoUntyped> IntoUntyped for Vec<T> {497 fn into_untyped(value: Self) -> Result<Val> {498 Ok(Val::Arr(499 value500 .into_iter()501 .map(T::into_untyped)502 .collect::<Result<ArrValue>>()?,503 ))504 }505}506impl<T: Typed + FromUntyped> FromUntyped for Vec<T> {507 fn from_untyped(value: Val) -> Result<Self> {508 let Val::Arr(a) = value else {509 <Self as Typed>::TYPE.check(&value)?;510 unreachable!("typecheck should fail")511 };512 a.iter()513 .enumerate()514 .map(|(i, r)| {515 r.and_then(|t| {516 T::from_untyped(t).with_description(|| format!("parsing elem <{i}>"))517 })518 })519 .collect::<Result<Self>>()520 }521}522523// TODO: View into BTreeMap using ObjectCore?524impl<K, V> Typed for BTreeMap<K, V>525where526 K: Typed + Ord,527 V: Typed,528{529 const TYPE: &'static ComplexValType = &ComplexValType::AttrsOf(V::TYPE);530}531impl<K, V> IntoUntyped for BTreeMap<K, V>532where533 K: Typed + Ord + IntoUntyped,534 V: Typed + IntoUntyped,535{536 fn into_untyped(typed: Self) -> Result<Val> {537 let mut out = ObjValueBuilder::with_capacity(typed.len());538 for (k, v) in typed {539 let Some(key) = K::into_untyped(k)?.as_str() else {540 bail!("map key should serialize to string");541 };542 let value = V::into_untyped(v)?;543 out.field(key).value(value);544 }545 Ok(Val::Obj(out.build()))546 }547}548impl<K, V> FromUntyped for BTreeMap<K, V>549where550 K: FromUntyped + Ord,551 V: FromUntyped,552{553 fn from_untyped(value: Val) -> Result<Self> {554 Self::TYPE.check(&value)?;555 let obj = value.as_obj().expect("typecheck should fail");556557 let mut out = Self::new();558 if V::wants_lazy() {559 for key in obj.fields_ex(560 false,561 #[cfg(feature = "exp-preserve-order")]562 false,563 ) {564 let value = obj.get_lazy(key.clone()).expect("field exists");565 let value = V::from_lazy_untyped(value)?;566 let key = K::from_untyped(Val::Str(key.into()))?;567 let _ = out.insert(key, value);568 }569 } else {570 for (key, value) in obj.iter(571 #[cfg(feature = "exp-preserve-order")]572 false,573 ) {574 let key = K::from_untyped(Val::Str(key.into()))?;575 let value = V::from_untyped(value?)?;576 let _ = out.insert(key, value);577 }578 }579 Ok(out)580 }581}582583impl Typed for Val {584 const TYPE: &'static ComplexValType = &ComplexValType::Any;585}586impl IntoUntyped for &Val {587 #[inline]588 fn into_untyped(typed: Self) -> Result<Val> {589 Ok(typed.clone())590 }591}592impl IntoUntyped for Val {593 #[inline]594 fn into_untyped(typed: Self) -> Result<Val> {595 Ok(typed)596 }597}598impl FromUntyped for Val {599 fn from_untyped(untyped: Val) -> Result<Self> {600 Ok(untyped)601 }602}603604#[doc(hidden)]605impl<T> Typed for Result<T>606where607 T: Typed,608{609 const TYPE: &'static ComplexValType = &ComplexValType::Any;610}611impl<T: IntoUntyped> IntoUntypedResult for Result<T> {612 fn into_untyped_result(typed: Self) -> Result<Val> {613 typed.map(T::into_untyped)?614 }615}616617/// Specialization618impl Typed for IBytes {619 const TYPE: &'static ComplexValType =620 &ComplexValType::ArrayRef(&ComplexValType::BoundedNumber(Some(0.0), Some(255.0)));621}622impl IntoUntyped for &IBytes {623 fn into_untyped(value: Self) -> Result<Val> {624 Ok(Val::arr(value.clone()))625 }626}627impl IntoUntyped for IBytes {628 fn into_untyped(value: Self) -> Result<Val> {629 Ok(Val::arr(value))630 }631}632impl FromUntyped for IBytes {633 fn from_untyped(value: Val) -> Result<Self> {634 let Val::Arr(a) = &value else {635 <Self as Typed>::TYPE.check(&value)?;636 unreachable!()637 };638 if let Some(bytes) = a.as_any().downcast_ref::<IBytes>() {639 return Ok(bytes.clone());640 }641 <Self as Typed>::TYPE.check(&value)?;642 // Any::downcast_ref::<ByteArray>(&a);643 let mut out = Vec::with_capacity(a.len());644 for e in a.iter() {645 let r = e?;646 out.push(u8::from_untyped(r)?);647 }648 Ok(out.as_slice().into())649 }650}651652pub struct M1;653impl Typed for M1 {654 const TYPE: &'static ComplexValType = &ComplexValType::BoundedNumber(Some(-1.0), Some(-1.0));655}656impl IntoUntyped for &M1 {657 fn into_untyped(_: Self) -> Result<Val> {658 Ok(Val::Num(NumValue::new(-1.0).expect("finite")))659 }660}661impl FromUntyped for M1 {662 fn from_untyped(value: Val) -> Result<Self> {663 <Self as Typed>::TYPE.check(&value)?;664 Ok(Self)665 }666}667668macro_rules! decl_either {669 ($($name: ident, $($id: ident)*);*) => {$(670 #[derive(Clone)]671 pub enum $name<$($id),*> {672 $($id($id)),*673 }674 impl<$($id),*> Typed for $name<$($id),*>675 where676 $($id: Typed,)*677 {678 const TYPE: &'static ComplexValType = &ComplexValType::UnionRef(&[$($id::TYPE),*]);679 }680 impl<$($id),*> IntoUntyped for $name<$($id),*>681 where682 $($id: Typed + IntoUntyped,)*683 {684 fn into_untyped(value: Self) -> Result<Val> {685 match value {$(686 $name::$id(v) => $id::into_untyped(v)687 ),*}688 }689 }690691 impl<$($id),*> FromUntyped for $name<$($id),*>692 where693 $($id: Typed + FromUntyped,)*694 {695 fn from_untyped(value: Val) -> Result<Self> {696 $(697 if $id::TYPE.check(&value).is_ok() {698 $id::from_untyped(value).map(Self::$id)699 } else700 )* {701 <Self as Typed>::TYPE.check(&value)?;702 unreachable!()703 }704 }705 }706 )*}707}708decl_either!(709 Either1, A;710 Either2, A B;711 Either3, A B C;712 Either4, A B C D;713 Either5, A B C D E;714 Either6, A B C D E F;715 Either7, A B C D E F G716);717#[macro_export]718macro_rules! Either {719 ($a:ty) => {$crate::typed::Either1<$a>};720 ($a:ty, $b:ty) => {$crate::typed::Either2<$a, $b>};721 ($a:ty, $b:ty, $c:ty) => {$crate::typed::Either3<$a, $b, $c>};722 ($a:ty, $b:ty, $c:ty, $d:ty) => {$crate::typed::Either4<$a, $b, $c, $d>};723 ($a:ty, $b:ty, $c:ty, $d:ty, $e:ty) => {$crate::typed::Either5<$a, $b, $c, $d, $e>};724 ($a:ty, $b:ty, $c:ty, $d:ty, $e:ty, $f:ty) => {$crate::typed::Either6<$a, $b, $c, $d, $e, $f>};725 ($a:ty, $b:ty, $c:ty, $d:ty, $e:ty, $f:ty, $g:ty) => {$crate::typed::Either7<$a, $b, $c, $d, $e, $f, $g>};726}727pub use Either;728729pub type MyType = Either![u32, f64, String];730731impl Typed for ArrValue {732 const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Arr);733}734impl IntoUntyped for ArrValue {735 fn into_untyped(value: Self) -> Result<Val> {736 Ok(Val::Arr(value))737 }738}739impl FromUntyped for ArrValue {740 fn from_untyped(value: Val) -> Result<Self> {741 <Self as Typed>::TYPE.check(&value)?;742 match value {743 Val::Arr(a) => Ok(a),744 _ => unreachable!(),745 }746 }747}748749impl Typed for FuncVal {750 const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Func);751}752impl IntoUntyped for FuncVal {753 fn into_untyped(value: Self) -> Result<Val> {754 Ok(Val::Func(value))755 }756}757impl FromUntyped for FuncVal {758 fn from_untyped(value: Val) -> Result<Self> {759 <Self as Typed>::TYPE.check(&value)?;760 match value {761 Val::Func(a) => Ok(a),762 _ => unreachable!(),763 }764 }765}766767impl Typed for ObjValue {768 const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Obj);769}770impl IntoUntyped for ObjValue {771 fn into_untyped(value: Self) -> Result<Val> {772 Ok(Val::Obj(value))773 }774}775impl FromUntyped for ObjValue {776 fn from_untyped(value: Val) -> Result<Self> {777 <Self as Typed>::TYPE.check(&value)?;778 match value {779 Val::Obj(a) => Ok(a),780 _ => unreachable!(),781 }782 }783}784785impl Typed for bool {786 const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Bool);787}788impl IntoUntyped for &bool {789 fn into_untyped(value: Self) -> Result<Val> {790 Ok(Val::Bool(*value))791 }792}793impl IntoUntyped for bool {794 fn into_untyped(value: Self) -> Result<Val> {795 Ok(Val::Bool(value))796 }797}798impl FromUntyped for bool {799 fn from_untyped(value: Val) -> Result<Self> {800 <Self as Typed>::TYPE.check(&value)?;801 match value {802 Val::Bool(a) => Ok(a),803 _ => unreachable!(),804 }805 }806}807808impl Typed for IndexableVal {809 const TYPE: &'static ComplexValType = &ComplexValType::UnionRef(&[810 &ComplexValType::Simple(ValType::Arr),811 &ComplexValType::Simple(ValType::Str),812 ]);813}814impl IntoUntyped for IndexableVal {815 fn into_untyped(value: Self) -> Result<Val> {816 match value {817 Self::Str(s) => Ok(Val::string(s)),818 Self::Arr(a) => Ok(Val::Arr(a)),819 }820 }821}822impl FromUntyped for IndexableVal {823 fn from_untyped(value: Val) -> Result<Self> {824 <Self as Typed>::TYPE.check(&value)?;825 value.into_indexable()826 }827}828829impl Typed for () {830 const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Null);831}832impl IntoUntyped for &() {833 fn into_untyped((): Self) -> Result<Val> {834 Ok(Val::Null)835 }836}837impl IntoUntyped for () {838 fn into_untyped((): Self) -> Result<Val> {839 Ok(Val::Null)840 }841}842impl FromUntyped for () {843 fn from_untyped(value: Val) -> Result<Self> {844 <Self as Typed>::TYPE.check(&value)?;845 Ok(())846 }847}848849impl<T> Typed for Option<T>850where851 T: Typed,852{853 const TYPE: &'static ComplexValType =854 &ComplexValType::UnionRef(&[&ComplexValType::Simple(ValType::Null), T::TYPE]);855}856impl<T> IntoUntyped for Option<T>857where858 T: Typed + IntoUntyped,859{860 fn into_untyped(typed: Self) -> Result<Val> {861 typed.map_or_else(|| Ok(Val::Null), |v| T::into_untyped(v))862 }863}864impl<T> FromUntyped for Option<T>865where866 T: Typed + FromUntyped,867{868 fn from_untyped(untyped: Val) -> Result<Self> {869 if matches!(untyped, Val::Null) {870 Ok(None)871 } else {872 T::from_untyped(untyped).map(Some)873 }874 }875}876877impl Typed for NumValue {878 const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Num);879}880impl IntoUntyped for &NumValue {881 fn into_untyped(typed: Self) -> Result<Val> {882 Ok(Val::Num(*typed))883 }884}885impl FromUntyped for NumValue {886 fn from_untyped(untyped: Val) -> Result<Self> {887 Self::TYPE.check(&untyped)?;888 match untyped {889 Val::Num(v) => Ok(v),890 _ => unreachable!(),891 }892 }893}