From e070270c3f1f10d46281ed7751ff95e15092e7f4 Mon Sep 17 00:00:00 2001 From: Nadrieril Date: Sun, 10 May 2020 22:09:43 +0100 Subject: Implement serialization --- serde_dhall/src/value.rs | 106 +++++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 103 insertions(+), 3 deletions(-) (limited to 'serde_dhall/src/value.rs') diff --git a/serde_dhall/src/value.rs b/serde_dhall/src/value.rs index d7116d9..ca05658 100644 --- a/serde_dhall/src/value.rs +++ b/serde_dhall/src/value.rs @@ -6,7 +6,7 @@ use dhall::semantics::{Hir, HirKind, Nir, NirKind}; pub use dhall::syntax::NumKind; use dhall::syntax::{Expr, ExprKind, Span}; -use crate::{Error, ErrorKind, FromDhall, Result, Sealed}; +use crate::{Error, ErrorKind, FromDhall, Result, ToDhall}; #[doc(hidden)] /// An arbitrary Dhall value. @@ -292,6 +292,94 @@ impl SimpleValue { _ => return None, }) } + + fn to_hir(&self, ty: &SimpleType) -> Result { + use SimpleType as T; + use SimpleValue as V; + let hir = |k| Hir::new(HirKind::Expr(k), Span::Artificial); + let type_error = |msg| Error(ErrorKind::Serialize(msg)); + let kind = match (self, ty) { + (V::Num(num @ NumKind::Bool(_)), T::Bool) + | (V::Num(num @ NumKind::Natural(_)), T::Natural) + | (V::Num(num @ NumKind::Integer(_)), T::Integer) + | (V::Num(num @ NumKind::Double(_)), T::Double) => { + ExprKind::Num(num.clone()) + } + (V::Text(v), T::Text) => ExprKind::TextLit(v.clone().into()), + (V::Optional(None), T::Optional(t)) => ExprKind::Op(OpKind::App( + hir(ExprKind::Builtin(Builtin::OptionalNone)), + t.to_hir(), + )), + (V::Optional(Some(v)), T::Optional(t)) => { + ExprKind::SomeLit(v.to_hir(t)?) + } + (V::List(v), T::List(t)) if v.is_empty() => { + ExprKind::EmptyListLit(hir(ExprKind::Op(OpKind::App( + hir(ExprKind::Builtin(Builtin::List)), + t.to_hir(), + )))) + } + (V::List(v), T::List(t)) => ExprKind::NEListLit( + v.iter().map(|v| v.to_hir(t)).collect::>()?, + ), + (V::Record(v), T::Record(t)) => ExprKind::RecordLit( + v.iter() + .map(|(k, v)| match t.get(k) { + Some(t) => Ok((k.clone().into(), v.to_hir(t)?)), + None => Err(type_error(format!( + "expected a value of type {}, found {:?}", + ty.to_hir().to_expr(Default::default()), + self + ))), + }) + .collect::>()?, + ), + (V::Union(variant, Some(v)), T::Union(t)) => match t.get(variant) { + Some(Some(variant_t)) => ExprKind::Op(OpKind::App( + hir(ExprKind::Op(OpKind::Field( + ty.to_hir(), + variant.clone().into(), + ))), + v.to_hir(variant_t)?, + )), + _ => { + return Err(type_error(format!( + "expected a value of type {}, found {:?}", + ty.to_hir().to_expr(Default::default()), + self + ))) + } + }, + (V::Union(variant, None), T::Union(t)) => match t.get(variant) { + Some(None) => ExprKind::Op(OpKind::Field( + ty.to_hir(), + variant.clone().into(), + )), + _ => { + return Err(type_error(format!( + "expected a value of type {}, found {:?}", + ty.to_hir().to_expr(Default::default()), + self + ))) + } + }, + _ => { + return Err(type_error(format!( + "expected a value of type {}, found {:?}", + ty.to_hir().to_expr(Default::default()), + self + ))) + } + }; + Ok(hir(kind)) + } + pub(crate) fn into_value(self, ty: &SimpleType) -> Result { + Ok(Value { + hir: self.to_hir(ty)?, + as_simple_val: Some(self), + as_simple_ty: None, + }) + } } impl SimpleType { @@ -376,8 +464,10 @@ impl SimpleType { } } -impl Sealed for Value {} -impl Sealed for SimpleType {} +impl crate::deserialize::Sealed for Value {} +impl crate::deserialize::Sealed for SimpleType {} +impl crate::serialize::Sealed for Value {} +impl crate::serialize::Sealed for SimpleValue {} impl FromDhall for Value { fn from_dhall(v: &Value) -> Result { @@ -394,6 +484,16 @@ impl FromDhall for SimpleType { }) } } +impl ToDhall for Value { + fn to_dhall(&self, _ty: &SimpleType) -> Result { + Ok(self.clone()) + } +} +impl ToDhall for SimpleValue { + fn to_dhall(&self, ty: &SimpleType) -> Result { + self.clone().into_value(ty) + } +} impl Eq for Value {} impl PartialEq for Value { -- cgit v1.2.3 From 3b728aff86a086f71f013b77a715c33748d9f6a8 Mon Sep 17 00:00:00 2001 From: Nadrieril Date: Wed, 28 Oct 2020 21:45:42 +0000 Subject: Make type annotation optional to allow serializing SimpleValue --- serde_dhall/src/value.rs | 140 +++++++++++++++++++++++++---------------------- 1 file changed, 75 insertions(+), 65 deletions(-) (limited to 'serde_dhall/src/value.rs') diff --git a/serde_dhall/src/value.rs b/serde_dhall/src/value.rs index ca05658..50c12bd 100644 --- a/serde_dhall/src/value.rs +++ b/serde_dhall/src/value.rs @@ -293,87 +293,103 @@ impl SimpleValue { }) } - fn to_hir(&self, ty: &SimpleType) -> Result { + // Converts this to `Hir`, using the optional type annotation. Without the type, things like + // empty lists and unions will fail to convert. + fn to_hir(&self, ty: Option<&SimpleType>) -> Result { use SimpleType as T; use SimpleValue as V; let hir = |k| Hir::new(HirKind::Expr(k), Span::Artificial); - let type_error = |msg| Error(ErrorKind::Serialize(msg)); + let type_error = || { + Error(ErrorKind::Serialize(format!( + "expected a value of type {}, found {:?}", + ty.unwrap().to_hir().to_expr(Default::default()), + self + ))) + }; + let type_missing = || { + Error(ErrorKind::Serialize(format!( + "cannot serialize value without a type annotation: {:?}", + self + ))) + }; let kind = match (self, ty) { - (V::Num(num @ NumKind::Bool(_)), T::Bool) - | (V::Num(num @ NumKind::Natural(_)), T::Natural) - | (V::Num(num @ NumKind::Integer(_)), T::Integer) - | (V::Num(num @ NumKind::Double(_)), T::Double) => { - ExprKind::Num(num.clone()) + (V::Num(num @ NumKind::Bool(_)), Some(T::Bool)) + | (V::Num(num @ NumKind::Natural(_)), Some(T::Natural)) + | (V::Num(num @ NumKind::Integer(_)), Some(T::Integer)) + | (V::Num(num @ NumKind::Double(_)), Some(T::Double)) + | (V::Num(num), None) => ExprKind::Num(num.clone()), + (V::Text(v), Some(T::Text)) | (V::Text(v), None) => { + ExprKind::TextLit(v.clone().into()) } - (V::Text(v), T::Text) => ExprKind::TextLit(v.clone().into()), - (V::Optional(None), T::Optional(t)) => ExprKind::Op(OpKind::App( - hir(ExprKind::Builtin(Builtin::OptionalNone)), - t.to_hir(), - )), - (V::Optional(Some(v)), T::Optional(t)) => { - ExprKind::SomeLit(v.to_hir(t)?) + + (V::Optional(None), None) => return Err(type_missing()), + (V::Optional(None), Some(T::Optional(t))) => { + ExprKind::Op(OpKind::App( + hir(ExprKind::Builtin(Builtin::OptionalNone)), + t.to_hir(), + )) + } + (V::Optional(Some(v)), None) => ExprKind::SomeLit(v.to_hir(None)?), + (V::Optional(Some(v)), Some(T::Optional(t))) => { + ExprKind::SomeLit(v.to_hir(Some(t))?) } - (V::List(v), T::List(t)) if v.is_empty() => { + + (V::List(v), None) if v.is_empty() => return Err(type_missing()), + (V::List(v), Some(T::List(t))) if v.is_empty() => { ExprKind::EmptyListLit(hir(ExprKind::Op(OpKind::App( hir(ExprKind::Builtin(Builtin::List)), t.to_hir(), )))) } - (V::List(v), T::List(t)) => ExprKind::NEListLit( - v.iter().map(|v| v.to_hir(t)).collect::>()?, + (V::List(v), None) => ExprKind::NEListLit( + v.iter().map(|v| v.to_hir(None)).collect::>()?, + ), + (V::List(v), Some(T::List(t))) => ExprKind::NEListLit( + v.iter().map(|v| v.to_hir(Some(t))).collect::>()?, + ), + + (V::Record(v), None) => ExprKind::RecordLit( + v.iter() + .map(|(k, v)| Ok((k.clone().into(), v.to_hir(None)?))) + .collect::>()?, ), - (V::Record(v), T::Record(t)) => ExprKind::RecordLit( + (V::Record(v), Some(T::Record(t))) => ExprKind::RecordLit( v.iter() .map(|(k, v)| match t.get(k) { - Some(t) => Ok((k.clone().into(), v.to_hir(t)?)), - None => Err(type_error(format!( - "expected a value of type {}, found {:?}", - ty.to_hir().to_expr(Default::default()), - self - ))), + Some(t) => Ok((k.clone().into(), v.to_hir(Some(t))?)), + None => Err(type_error()), }) .collect::>()?, ), - (V::Union(variant, Some(v)), T::Union(t)) => match t.get(variant) { - Some(Some(variant_t)) => ExprKind::Op(OpKind::App( - hir(ExprKind::Op(OpKind::Field( - ty.to_hir(), - variant.clone().into(), - ))), - v.to_hir(variant_t)?, - )), - _ => { - return Err(type_error(format!( - "expected a value of type {}, found {:?}", - ty.to_hir().to_expr(Default::default()), - self - ))) + + (V::Union(..), None) => return Err(type_missing()), + (V::Union(variant, Some(v)), Some(T::Union(t))) => { + match t.get(variant) { + Some(Some(variant_t)) => ExprKind::Op(OpKind::App( + hir(ExprKind::Op(OpKind::Field( + ty.unwrap().to_hir(), + variant.clone().into(), + ))), + v.to_hir(Some(variant_t))?, + )), + _ => return Err(type_error()), } - }, - (V::Union(variant, None), T::Union(t)) => match t.get(variant) { - Some(None) => ExprKind::Op(OpKind::Field( - ty.to_hir(), - variant.clone().into(), - )), - _ => { - return Err(type_error(format!( - "expected a value of type {}, found {:?}", - ty.to_hir().to_expr(Default::default()), - self - ))) + } + (V::Union(variant, None), Some(T::Union(t))) => { + match t.get(variant) { + Some(None) => ExprKind::Op(OpKind::Field( + ty.unwrap().to_hir(), + variant.clone().into(), + )), + _ => return Err(type_error()), } - }, - _ => { - return Err(type_error(format!( - "expected a value of type {}, found {:?}", - ty.to_hir().to_expr(Default::default()), - self - ))) } + + (_, Some(_)) => return Err(type_error()), }; Ok(hir(kind)) } - pub(crate) fn into_value(self, ty: &SimpleType) -> Result { + pub(crate) fn into_value(self, ty: Option<&SimpleType>) -> Result { Ok(Value { hir: self.to_hir(ty)?, as_simple_val: Some(self), @@ -467,7 +483,6 @@ impl SimpleType { impl crate::deserialize::Sealed for Value {} impl crate::deserialize::Sealed for SimpleType {} impl crate::serialize::Sealed for Value {} -impl crate::serialize::Sealed for SimpleValue {} impl FromDhall for Value { fn from_dhall(v: &Value) -> Result { @@ -485,15 +500,10 @@ impl FromDhall for SimpleType { } } impl ToDhall for Value { - fn to_dhall(&self, _ty: &SimpleType) -> Result { + fn to_dhall(&self, _ty: Option<&SimpleType>) -> Result { Ok(self.clone()) } } -impl ToDhall for SimpleValue { - fn to_dhall(&self, ty: &SimpleType) -> Result { - self.clone().into_value(ty) - } -} impl Eq for Value {} impl PartialEq for Value { -- cgit v1.2.3 From 48bb9c03b0ace9efa33315e06c47a868e5c4ed36 Mon Sep 17 00:00:00 2001 From: Nadrieril Date: Wed, 28 Oct 2020 22:43:34 +0000 Subject: Move table of type correspondances --- serde_dhall/src/value.rs | 23 ++++++++++++++++++++++- 1 file changed, 22 insertions(+), 1 deletion(-) (limited to 'serde_dhall/src/value.rs') diff --git a/serde_dhall/src/value.rs b/serde_dhall/src/value.rs index 50c12bd..b8ad199 100644 --- a/serde_dhall/src/value.rs +++ b/serde_dhall/src/value.rs @@ -124,6 +124,28 @@ pub enum SimpleValue { /// [`StaticType`]: trait.StaticType.html /// [`Deserializer::static_type_annotation`]: options/struct.Deserializer.html#method.static_type_annotation /// +/// # Type correspondence +/// +/// The following Dhall types correspond to the following Rust types: +/// +/// Dhall | Rust +/// -------|------ +/// `Bool` | `bool` +/// `Natural` | `u64`, `u32`, ... +/// `Integer` | `i64`, `i32`, ... +/// `Double` | `f64`, `f32`, ... +/// `Text` | `String` +/// `List T` | `Vec` +/// `Optional T` | `Option` +/// `{ x: T, y: U }` | structs +/// `{ _1: T, _2: U }` | `(T, U)`, structs +/// `{ x: T, y: T }` | `HashMap`, structs +/// `< x: T \| y: U >` | enums +/// `Prelude.Map.Type Text T` | `HashMap`, structs +/// `T -> U` | unsupported +/// `Prelude.JSON.Type` | unsupported +/// `Prelude.Map.Type T U` | unsupported +/// /// # Examples /// /// ```rust @@ -159,7 +181,6 @@ pub enum SimpleValue { /// # Ok(()) /// # } /// ``` -/// #[derive(Debug, Clone, PartialEq, Eq)] pub enum SimpleType { /// Corresponds to the Dhall type `Bool` -- cgit v1.2.3