From 84796fd247eb1a13fcd092a7cd7ec2d587b261bd Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Sun, 8 Mar 2020 17:11:34 +0000
Subject: Add SimpleValue type to facilitate deserialization

---
 serde_dhall/src/lib.rs | 17 +++++++++++------
 1 file changed, 11 insertions(+), 6 deletions(-)

(limited to 'serde_dhall/src/lib.rs')

diff --git a/serde_dhall/src/lib.rs b/serde_dhall/src/lib.rs
index 0a53420..55e098c 100644
--- a/serde_dhall/src/lib.rs
+++ b/serde_dhall/src/lib.rs
@@ -182,16 +182,19 @@ pub use value::Value;
 #[doc(hidden)]
 pub mod value {
     use dhall::syntax::Builtin;
-    use dhall::{Normalized, NormalizedExpr, Parsed};
+    use dhall::{Normalized, NormalizedExpr, Parsed, SimpleValue};
 
-    use super::de::{Error, Result};
+    use super::de::Error;
 
     /// A Dhall value
     #[derive(Debug, Clone, PartialEq, Eq)]
     pub struct Value(Normalized);
 
     impl Value {
-        pub fn from_str(s: &str, ty: Option<&Value>) -> Result<Self> {
+        pub fn from_str(
+            s: &str,
+            ty: Option<&Value>,
+        ) -> super::de::Result<Self> {
             Value::from_str_using_dhall_error_type(s, ty).map_err(Error::Dhall)
         }
         fn from_str_using_dhall_error_type(
@@ -205,8 +208,10 @@ pub mod value {
             };
             Ok(Value(typed.normalize()))
         }
-        pub(crate) fn to_expr(&self) -> NormalizedExpr {
-            self.0.to_expr()
+        pub(crate) fn to_simple_value(
+            &self,
+        ) -> Result<SimpleValue, NormalizedExpr> {
+            self.0.to_simple_value()
         }
         pub(crate) fn as_normalized(&self) -> &Normalized {
             &self.0
@@ -241,7 +246,7 @@ pub mod value {
     impl super::de::sealed::Sealed for Value {}
 
     impl super::de::Deserialize for Value {
-        fn from_dhall(v: &Value) -> Result<Self> {
+        fn from_dhall(v: &Value) -> super::de::Result<Self> {
             Ok(v.clone())
         }
     }
-- 
cgit v1.2.3


From 4e11e882b7d064e9ddf997f9a465206cf6e471aa Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Sun, 8 Mar 2020 17:36:51 +0000
Subject: Split serde_dhall::Value to separate values from types

---
 serde_dhall/src/lib.rs | 86 ++++++++++++++++++++++++++++++++++++--------------
 1 file changed, 62 insertions(+), 24 deletions(-)

(limited to 'serde_dhall/src/lib.rs')

diff --git a/serde_dhall/src/lib.rs b/serde_dhall/src/lib.rs
index 55e098c..5f386e3 100644
--- a/serde_dhall/src/lib.rs
+++ b/serde_dhall/src/lib.rs
@@ -106,17 +106,17 @@
 //! There are two ways to typecheck a Dhall value: you can provide the type as Dhall text or you
 //! can let Rust infer it for you.
 //!
-//! To provide a type written in Dhall, first parse it into a [`serde_dhall::Value`][Value], then
+//! To provide a type written in Dhall, first parse it into a [`serde_dhall::Type`][Type], then
 //! pass it to [`from_str_check_type`][from_str_check_type].
 //!
 //! ```rust
 //! # fn main() -> serde_dhall::de::Result<()> {
-//! use serde_dhall::Value;
+//! use serde_dhall::Type;
 //! use std::collections::HashMap;
 //!
 //! // Parse a Dhall type
 //! let point_type_str = "{ x: Natural, y: Natural }";
-//! let point_type: Value = serde_dhall::from_str(point_type_str)?;
+//! let point_type: Type = serde_dhall::from_str(point_type_str)?;
 //!
 //! // Some Dhall data
 //! let point_data = "{ x = 1, y = 1 + 1 }";
@@ -176,30 +176,29 @@ pub use de::{from_str, from_str_auto_type, from_str_check_type};
 pub use dhall_proc_macros::StaticType;
 pub use static_type::StaticType;
 #[doc(inline)]
+pub use ty::Type;
+#[doc(inline)]
 pub use value::Value;
 
 // A Dhall value.
 #[doc(hidden)]
 pub mod value {
-    use dhall::syntax::Builtin;
     use dhall::{Normalized, NormalizedExpr, Parsed, SimpleValue};
 
     use super::de::Error;
+    use super::Type;
 
     /// A Dhall value
     #[derive(Debug, Clone, PartialEq, Eq)]
-    pub struct Value(Normalized);
+    pub struct Value(pub(crate) Normalized);
 
     impl Value {
-        pub fn from_str(
-            s: &str,
-            ty: Option<&Value>,
-        ) -> super::de::Result<Self> {
+        pub fn from_str(s: &str, ty: Option<&Type>) -> super::de::Result<Self> {
             Value::from_str_using_dhall_error_type(s, ty).map_err(Error::Dhall)
         }
         fn from_str_using_dhall_error_type(
             s: &str,
-            ty: Option<&Value>,
+            ty: Option<&Type>,
         ) -> dhall::error::Result<Self> {
             let resolved = Parsed::parse_str(s)?.resolve()?;
             let typed = match ty {
@@ -213,41 +212,79 @@ pub mod value {
         ) -> Result<SimpleValue, NormalizedExpr> {
             self.0.to_simple_value()
         }
+    }
+
+    impl super::de::sealed::Sealed for Value {}
+
+    impl super::de::Deserialize for Value {
+        fn from_dhall(v: &Value) -> super::de::Result<Self> {
+            Ok(v.clone())
+        }
+    }
+}
+
+// A Dhall type.
+#[doc(hidden)]
+pub mod ty {
+    use dhall::syntax::Builtin;
+    use dhall::{Normalized, Parsed};
+
+    use super::de::Error;
+
+    /// A Dhall value
+    #[derive(Debug, Clone, PartialEq, Eq)]
+    pub struct Type(Normalized);
+
+    impl Type {
+        pub fn from_str(s: &str, ty: Option<&Type>) -> super::de::Result<Self> {
+            Type::from_str_using_dhall_error_type(s, ty).map_err(Error::Dhall)
+        }
+        fn from_str_using_dhall_error_type(
+            s: &str,
+            ty: Option<&Type>,
+        ) -> dhall::error::Result<Self> {
+            let resolved = Parsed::parse_str(s)?.resolve()?;
+            let typed = match ty {
+                None => resolved.typecheck()?,
+                Some(t) => resolved.typecheck_with(t.as_normalized())?,
+            };
+            Ok(Type(typed.normalize()))
+        }
         pub(crate) fn as_normalized(&self) -> &Normalized {
             &self.0
         }
 
         pub(crate) fn make_builtin_type(b: Builtin) -> Self {
-            Value(Normalized::make_builtin_type(b))
+            Type(Normalized::make_builtin_type(b))
         }
-        pub(crate) fn make_optional_type(t: Value) -> Self {
-            Value(Normalized::make_optional_type(t.0))
+        pub(crate) fn make_optional_type(t: Type) -> Self {
+            Type(Normalized::make_optional_type(t.0))
         }
-        pub(crate) fn make_list_type(t: Value) -> Self {
-            Value(Normalized::make_list_type(t.0))
+        pub(crate) fn make_list_type(t: Type) -> Self {
+            Type(Normalized::make_list_type(t.0))
         }
         // Made public for the StaticType derive macro
         #[doc(hidden)]
         pub fn make_record_type(
-            kts: impl Iterator<Item = (String, Value)>,
+            kts: impl Iterator<Item = (String, Type)>,
         ) -> Self {
-            Value(Normalized::make_record_type(kts.map(|(k, t)| (k, t.0))))
+            Type(Normalized::make_record_type(kts.map(|(k, t)| (k, t.0))))
         }
         #[doc(hidden)]
         pub fn make_union_type(
-            kts: impl Iterator<Item = (String, Option<Value>)>,
+            kts: impl Iterator<Item = (String, Option<Type>)>,
         ) -> Self {
-            Value(Normalized::make_union_type(
+            Type(Normalized::make_union_type(
                 kts.map(|(k, t)| (k, t.map(|t| t.0))),
             ))
         }
     }
 
-    impl super::de::sealed::Sealed for Value {}
+    impl super::de::sealed::Sealed for Type {}
 
-    impl super::de::Deserialize for Value {
-        fn from_dhall(v: &Value) -> super::de::Result<Self> {
-            Ok(v.clone())
+    impl super::de::Deserialize for Type {
+        fn from_dhall(v: &super::Value) -> super::de::Result<Self> {
+            Ok(Type(v.0.clone()))
         }
     }
 }
@@ -255,6 +292,7 @@ pub mod value {
 /// Deserialize Dhall data to a Rust data structure.
 pub mod de {
     use super::StaticType;
+    use super::Type;
     use super::Value;
     pub use error::{Error, Result};
 
@@ -324,7 +362,7 @@ pub mod de {
     ///
     /// Like [from_str], but this additionally checks that
     /// the type of the provided expression matches the supplied type.
-    pub fn from_str_check_type<T>(s: &str, ty: &Value) -> Result<T>
+    pub fn from_str_check_type<T>(s: &str, ty: &Type) -> Result<T>
     where
         T: Deserialize,
     {
-- 
cgit v1.2.3


From 94850b720b0171444694452027f1baf947b3c18f Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Sun, 8 Mar 2020 21:47:26 +0000
Subject: Add SimpleType to mirror SimpleValue

---
 serde_dhall/src/lib.rs | 61 +++++++++++++++++++++++++-------------------------
 1 file changed, 31 insertions(+), 30 deletions(-)

(limited to 'serde_dhall/src/lib.rs')

diff --git a/serde_dhall/src/lib.rs b/serde_dhall/src/lib.rs
index 5f386e3..d019238 100644
--- a/serde_dhall/src/lib.rs
+++ b/serde_dhall/src/lib.rs
@@ -183,7 +183,7 @@ pub use value::Value;
 // A Dhall value.
 #[doc(hidden)]
 pub mod value {
-    use dhall::{Normalized, NormalizedExpr, Parsed, SimpleValue};
+    use dhall::{Normalized, NormalizedExpr, Parsed, SimpleType, SimpleValue};
 
     use super::de::Error;
     use super::Type;
@@ -203,7 +203,7 @@ pub mod value {
             let resolved = Parsed::parse_str(s)?.resolve()?;
             let typed = match ty {
                 None => resolved.typecheck()?,
-                Some(t) => resolved.typecheck_with(t.as_normalized())?,
+                Some(t) => resolved.typecheck_with(&t.to_normalized())?,
             };
             Ok(Value(typed.normalize()))
         }
@@ -212,6 +212,11 @@ pub mod value {
         ) -> Result<SimpleValue, NormalizedExpr> {
             self.0.to_simple_value()
         }
+        pub(crate) fn to_simple_type(
+            &self,
+        ) -> Result<SimpleType, NormalizedExpr> {
+            self.0.to_simple_type()
+        }
     }
 
     impl super::de::sealed::Sealed for Value {}
@@ -226,56 +231,46 @@ pub mod value {
 // A Dhall type.
 #[doc(hidden)]
 pub mod ty {
-    use dhall::syntax::Builtin;
-    use dhall::{Normalized, Parsed};
+    use dhall::{Normalized, STyKind, SimpleType};
 
     use super::de::Error;
 
-    /// A Dhall value
+    /// A Dhall type
     #[derive(Debug, Clone, PartialEq, Eq)]
-    pub struct Type(Normalized);
+    pub struct Type(SimpleType);
 
     impl Type {
-        pub fn from_str(s: &str, ty: Option<&Type>) -> super::de::Result<Self> {
-            Type::from_str_using_dhall_error_type(s, ty).map_err(Error::Dhall)
-        }
-        fn from_str_using_dhall_error_type(
-            s: &str,
-            ty: Option<&Type>,
-        ) -> dhall::error::Result<Self> {
-            let resolved = Parsed::parse_str(s)?.resolve()?;
-            let typed = match ty {
-                None => resolved.typecheck()?,
-                Some(t) => resolved.typecheck_with(t.as_normalized())?,
-            };
-            Ok(Type(typed.normalize()))
-        }
-        pub(crate) fn as_normalized(&self) -> &Normalized {
-            &self.0
+        pub(crate) fn to_normalized(&self) -> Normalized {
+            self.0.clone().into_normalized()
         }
 
-        pub(crate) fn make_builtin_type(b: Builtin) -> Self {
-            Type(Normalized::make_builtin_type(b))
+        pub(crate) fn from_simple_type(ty: SimpleType) -> Self {
+            Type(ty)
+        }
+        pub(crate) fn from_stykind(k: STyKind) -> Self {
+            Type(SimpleType::new(k))
         }
         pub(crate) fn make_optional_type(t: Type) -> Self {
-            Type(Normalized::make_optional_type(t.0))
+            Type::from_stykind(STyKind::Optional(t.0))
         }
         pub(crate) fn make_list_type(t: Type) -> Self {
-            Type(Normalized::make_list_type(t.0))
+            Type::from_stykind(STyKind::List(t.0))
         }
         // Made public for the StaticType derive macro
         #[doc(hidden)]
         pub fn make_record_type(
             kts: impl Iterator<Item = (String, Type)>,
         ) -> Self {
-            Type(Normalized::make_record_type(kts.map(|(k, t)| (k, t.0))))
+            Type::from_stykind(STyKind::Record(
+                kts.map(|(k, t)| (k, t.0)).collect(),
+            ))
         }
         #[doc(hidden)]
         pub fn make_union_type(
             kts: impl Iterator<Item = (String, Option<Type>)>,
         ) -> Self {
-            Type(Normalized::make_union_type(
-                kts.map(|(k, t)| (k, t.map(|t| t.0))),
+            Type::from_stykind(STyKind::Union(
+                kts.map(|(k, t)| (k, t.map(|t| t.0))).collect(),
             ))
         }
     }
@@ -284,7 +279,13 @@ pub mod ty {
 
     impl super::de::Deserialize for Type {
         fn from_dhall(v: &super::Value) -> super::de::Result<Self> {
-            Ok(Type(v.0.clone()))
+            let sty = v.to_simple_type().map_err(|expr| {
+                Error::Deserialize(format!(
+                    "this cannot be deserialized into a simple type: {}",
+                    expr
+                ))
+            })?;
+            Ok(Type(sty))
         }
     }
 }
-- 
cgit v1.2.3


From 60425d58151fef142b066d523dc4d5e832070b9c Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Fri, 13 Mar 2020 14:30:15 +0000
Subject: Add new Value type in API

---
 serde_dhall/src/lib.rs | 47 ++++++++++++++++++++++-------------------------
 1 file changed, 22 insertions(+), 25 deletions(-)

(limited to 'serde_dhall/src/lib.rs')

diff --git a/serde_dhall/src/lib.rs b/serde_dhall/src/lib.rs
index d019238..1f7ecf8 100644
--- a/serde_dhall/src/lib.rs
+++ b/serde_dhall/src/lib.rs
@@ -183,38 +183,26 @@ pub use value::Value;
 // A Dhall value.
 #[doc(hidden)]
 pub mod value {
-    use dhall::{Normalized, NormalizedExpr, Parsed, SimpleType, SimpleValue};
+    use dhall::{SimpleType, SimpleValue};
 
     use super::de::Error;
     use super::Type;
 
     /// A Dhall value
     #[derive(Debug, Clone, PartialEq, Eq)]
-    pub struct Value(pub(crate) Normalized);
+    pub struct Value(pub(crate) dhall::Value);
 
     impl Value {
         pub fn from_str(s: &str, ty: Option<&Type>) -> super::de::Result<Self> {
-            Value::from_str_using_dhall_error_type(s, ty).map_err(Error::Dhall)
+            let ty = ty.map(|t| t.to_dhall_value());
+            let val = dhall::Value::from_str_with_annot(s, ty.as_ref())
+                .map_err(Error::Dhall)?;
+            Ok(Value(val))
         }
-        fn from_str_using_dhall_error_type(
-            s: &str,
-            ty: Option<&Type>,
-        ) -> dhall::error::Result<Self> {
-            let resolved = Parsed::parse_str(s)?.resolve()?;
-            let typed = match ty {
-                None => resolved.typecheck()?,
-                Some(t) => resolved.typecheck_with(&t.to_normalized())?,
-            };
-            Ok(Value(typed.normalize()))
-        }
-        pub(crate) fn to_simple_value(
-            &self,
-        ) -> Result<SimpleValue, NormalizedExpr> {
+        pub(crate) fn to_simple_value(&self) -> Option<SimpleValue> {
             self.0.to_simple_value()
         }
-        pub(crate) fn to_simple_type(
-            &self,
-        ) -> Result<SimpleType, NormalizedExpr> {
+        pub(crate) fn to_simple_type(&self) -> Option<SimpleType> {
             self.0.to_simple_type()
         }
     }
@@ -226,12 +214,21 @@ pub mod value {
             Ok(v.clone())
         }
     }
+
+    impl std::fmt::Display for Value {
+        fn fmt(
+            &self,
+            f: &mut std::fmt::Formatter,
+        ) -> Result<(), std::fmt::Error> {
+            self.0.fmt(f)
+        }
+    }
 }
 
 // A Dhall type.
 #[doc(hidden)]
 pub mod ty {
-    use dhall::{Normalized, STyKind, SimpleType};
+    use dhall::{STyKind, SimpleType};
 
     use super::de::Error;
 
@@ -240,8 +237,8 @@ pub mod ty {
     pub struct Type(SimpleType);
 
     impl Type {
-        pub(crate) fn to_normalized(&self) -> Normalized {
-            self.0.clone().into_normalized()
+        pub(crate) fn to_dhall_value(&self) -> dhall::Value {
+            self.0.clone().into_normalized().to_value()
         }
 
         pub(crate) fn from_simple_type(ty: SimpleType) -> Self {
@@ -279,10 +276,10 @@ pub mod ty {
 
     impl super::de::Deserialize for Type {
         fn from_dhall(v: &super::Value) -> super::de::Result<Self> {
-            let sty = v.to_simple_type().map_err(|expr| {
+            let sty = v.to_simple_type().ok_or_else(|| {
                 Error::Deserialize(format!(
                     "this cannot be deserialized into a simple type: {}",
-                    expr
+                    v
                 ))
             })?;
             Ok(Type(sty))
-- 
cgit v1.2.3


From 6fdae6f8026fe9357de63c5557676f4def3eaf92 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Fri, 13 Mar 2020 16:16:56 +0000
Subject: Remove Normalized and friends from public API

---
 serde_dhall/src/lib.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'serde_dhall/src/lib.rs')

diff --git a/serde_dhall/src/lib.rs b/serde_dhall/src/lib.rs
index 1f7ecf8..103fdc3 100644
--- a/serde_dhall/src/lib.rs
+++ b/serde_dhall/src/lib.rs
@@ -238,7 +238,7 @@ pub mod ty {
 
     impl Type {
         pub(crate) fn to_dhall_value(&self) -> dhall::Value {
-            self.0.clone().into_normalized().to_value()
+            self.0.to_value()
         }
 
         pub(crate) fn from_simple_type(ty: SimpleType) -> Self {
-- 
cgit v1.2.3


From b3a05d930dd8f2bbc705145219025af96e5dec86 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Fri, 13 Mar 2020 20:16:08 +0000
Subject: Use dhall::Value more in serde

---
 serde_dhall/src/lib.rs | 65 +++++++++++++++++++++++++-------------------------
 1 file changed, 32 insertions(+), 33 deletions(-)

(limited to 'serde_dhall/src/lib.rs')

diff --git a/serde_dhall/src/lib.rs b/serde_dhall/src/lib.rs
index 103fdc3..134528c 100644
--- a/serde_dhall/src/lib.rs
+++ b/serde_dhall/src/lib.rs
@@ -183,44 +183,31 @@ pub use value::Value;
 // A Dhall value.
 #[doc(hidden)]
 pub mod value {
-    use dhall::{SimpleType, SimpleValue};
+    use dhall::SimpleValue;
 
     use super::de::Error;
-    use super::Type;
 
-    /// A Dhall value
+    /// A Dhall value. This is a wrapper around [`dhall::SimpleValue`].
     #[derive(Debug, Clone, PartialEq, Eq)]
-    pub struct Value(pub(crate) dhall::Value);
+    pub struct Value(SimpleValue);
 
     impl Value {
-        pub fn from_str(s: &str, ty: Option<&Type>) -> super::de::Result<Self> {
-            let ty = ty.map(|t| t.to_dhall_value());
-            let val = dhall::Value::from_str_with_annot(s, ty.as_ref())
-                .map_err(Error::Dhall)?;
-            Ok(Value(val))
-        }
-        pub(crate) fn to_simple_value(&self) -> Option<SimpleValue> {
-            self.0.to_simple_value()
-        }
-        pub(crate) fn to_simple_type(&self) -> Option<SimpleType> {
-            self.0.to_simple_type()
+        pub fn into_simple_value(self) -> SimpleValue {
+            self.0
         }
     }
 
     impl super::de::sealed::Sealed for Value {}
 
     impl super::de::Deserialize for Value {
-        fn from_dhall(v: &Value) -> super::de::Result<Self> {
-            Ok(v.clone())
-        }
-    }
-
-    impl std::fmt::Display for Value {
-        fn fmt(
-            &self,
-            f: &mut std::fmt::Formatter,
-        ) -> Result<(), std::fmt::Error> {
-            self.0.fmt(f)
+        fn from_dhall(v: &dhall::Value) -> super::de::Result<Self> {
+            let sval = v.to_simple_value().ok_or_else(|| {
+                Error::Deserialize(format!(
+                    "this cannot be deserialized into a simple type: {}",
+                    v
+                ))
+            })?;
+            Ok(Value(sval))
         }
     }
 }
@@ -232,12 +219,15 @@ pub mod ty {
 
     use super::de::Error;
 
-    /// A Dhall type
+    /// A Dhall type. This is a wrapper around [`dhall::SimpleType`].
     #[derive(Debug, Clone, PartialEq, Eq)]
     pub struct Type(SimpleType);
 
     impl Type {
-        pub(crate) fn to_dhall_value(&self) -> dhall::Value {
+        pub fn into_simple_type(self) -> SimpleType {
+            self.0
+        }
+        pub fn to_dhall_value(&self) -> dhall::Value {
             self.0.to_value()
         }
 
@@ -275,7 +265,7 @@ pub mod ty {
     impl super::de::sealed::Sealed for Type {}
 
     impl super::de::Deserialize for Type {
-        fn from_dhall(v: &super::Value) -> super::de::Result<Self> {
+        fn from_dhall(v: &dhall::Value) -> super::de::Result<Self> {
             let sty = v.to_simple_type().ok_or_else(|| {
                 Error::Deserialize(format!(
                     "this cannot be deserialized into a simple type: {}",
@@ -291,7 +281,6 @@ pub mod ty {
 pub mod de {
     use super::StaticType;
     use super::Type;
-    use super::Value;
     pub use error::{Error, Result};
 
     mod error {
@@ -339,7 +328,17 @@ pub mod de {
     /// This trait cannot be implemented manually.
     pub trait Deserialize: sealed::Sealed + Sized {
         /// See [serde_dhall::from_str][crate::from_str]
-        fn from_dhall(v: &Value) -> Result<Self>;
+        fn from_dhall(v: &dhall::Value) -> Result<Self>;
+    }
+
+    fn from_str_with_annot<T>(s: &str, ty: Option<&Type>) -> Result<T>
+    where
+        T: Deserialize,
+    {
+        let ty = ty.map(|ty| ty.to_dhall_value());
+        let val = dhall::Value::from_str_with_annot(s, ty.as_ref())
+            .map_err(Error::Dhall)?;
+        T::from_dhall(&val)
     }
 
     /// Deserialize an instance of type `T` from a string of Dhall text.
@@ -352,7 +351,7 @@ pub mod de {
     where
         T: Deserialize,
     {
-        T::from_dhall(&Value::from_str(s, None)?)
+        from_str_with_annot(s, None)
     }
 
     /// Deserialize an instance of type `T` from a string of Dhall text,
@@ -364,7 +363,7 @@ pub mod de {
     where
         T: Deserialize,
     {
-        T::from_dhall(&Value::from_str(s, Some(ty))?)
+        from_str_with_annot(s, Some(ty))
     }
 
     /// Deserialize an instance of type `T` from a string of Dhall text,
-- 
cgit v1.2.3


From 1a0929b52af57d5963dd9da9e5cf85ffbed3a8f7 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Fri, 13 Mar 2020 20:53:23 +0000
Subject: Reorganize serde modules

---
 serde_dhall/src/lib.rs | 264 ++++++++++++-------------------------------------
 1 file changed, 63 insertions(+), 201 deletions(-)

(limited to 'serde_dhall/src/lib.rs')

diff --git a/serde_dhall/src/lib.rs b/serde_dhall/src/lib.rs
index 134528c..15f45ce 100644
--- a/serde_dhall/src/lib.rs
+++ b/serde_dhall/src/lib.rs
@@ -22,7 +22,7 @@
 //! This could mean a common Rust type like `HashMap`:
 //!
 //! ```rust
-//! # fn main() -> serde_dhall::de::Result<()> {
+//! # fn main() -> serde_dhall::Result<()> {
 //! use std::collections::HashMap;
 //!
 //! // Some Dhall data
@@ -43,7 +43,7 @@
 //! or a custom datatype, using serde's `derive` mechanism:
 //!
 //! ```rust
-//! # fn main() -> serde_dhall::de::Result<()> {
+//! # fn main() -> serde_dhall::Result<()> {
 //! use serde::Deserialize;
 //!
 //! #[derive(Debug, Deserialize)]
@@ -110,8 +110,8 @@
 //! pass it to [`from_str_check_type`][from_str_check_type].
 //!
 //! ```rust
-//! # fn main() -> serde_dhall::de::Result<()> {
-//! use serde_dhall::Type;
+//! # fn main() -> serde_dhall::Result<()> {
+//! use serde_dhall::simple::Type;
 //! use std::collections::HashMap;
 //!
 //! // Parse a Dhall type
@@ -138,7 +138,7 @@
 //! You can also let Rust infer the appropriate Dhall type, using the [StaticType] trait.
 //!
 //! ```rust
-//! # fn main() -> serde_dhall::de::Result<()> {
+//! # fn main() -> serde_dhall::Result<()> {
 //! use serde::Deserialize;
 //! use serde_dhall::StaticType;
 //!
@@ -167,215 +167,77 @@
 //! [serde]: https://docs.serde.rs/serde/
 //! [serde::Deserialize]: https://docs.serde.rs/serde/trait.Deserialize.html
 
+mod error;
 mod serde;
+pub mod simple;
 mod static_type;
 
-#[doc(inline)]
-pub use de::{from_str, from_str_auto_type, from_str_check_type};
 #[doc(hidden)]
 pub use dhall_proc_macros::StaticType;
+pub use error::{Error, Result};
 pub use static_type::StaticType;
-#[doc(inline)]
-pub use ty::Type;
-#[doc(inline)]
-pub use value::Value;
 
-// A Dhall value.
-#[doc(hidden)]
-pub mod value {
-    use dhall::SimpleValue;
-
-    use super::de::Error;
-
-    /// A Dhall value. This is a wrapper around [`dhall::SimpleValue`].
-    #[derive(Debug, Clone, PartialEq, Eq)]
-    pub struct Value(SimpleValue);
+use simple::Type;
 
-    impl Value {
-        pub fn into_simple_value(self) -> SimpleValue {
-            self.0
-        }
-    }
-
-    impl super::de::sealed::Sealed for Value {}
-
-    impl super::de::Deserialize for Value {
-        fn from_dhall(v: &dhall::Value) -> super::de::Result<Self> {
-            let sval = v.to_simple_value().ok_or_else(|| {
-                Error::Deserialize(format!(
-                    "this cannot be deserialized into a simple type: {}",
-                    v
-                ))
-            })?;
-            Ok(Value(sval))
-        }
-    }
+pub(crate) mod sealed {
+    pub trait Sealed {}
 }
 
-// A Dhall type.
-#[doc(hidden)]
-pub mod ty {
-    use dhall::{STyKind, SimpleType};
-
-    use super::de::Error;
-
-    /// A Dhall type. This is a wrapper around [`dhall::SimpleType`].
-    #[derive(Debug, Clone, PartialEq, Eq)]
-    pub struct Type(SimpleType);
-
-    impl Type {
-        pub fn into_simple_type(self) -> SimpleType {
-            self.0
-        }
-        pub fn to_dhall_value(&self) -> dhall::Value {
-            self.0.to_value()
-        }
-
-        pub(crate) fn from_simple_type(ty: SimpleType) -> Self {
-            Type(ty)
-        }
-        pub(crate) fn from_stykind(k: STyKind) -> Self {
-            Type(SimpleType::new(k))
-        }
-        pub(crate) fn make_optional_type(t: Type) -> Self {
-            Type::from_stykind(STyKind::Optional(t.0))
-        }
-        pub(crate) fn make_list_type(t: Type) -> Self {
-            Type::from_stykind(STyKind::List(t.0))
-        }
-        // Made public for the StaticType derive macro
-        #[doc(hidden)]
-        pub fn make_record_type(
-            kts: impl Iterator<Item = (String, Type)>,
-        ) -> Self {
-            Type::from_stykind(STyKind::Record(
-                kts.map(|(k, t)| (k, t.0)).collect(),
-            ))
-        }
-        #[doc(hidden)]
-        pub fn make_union_type(
-            kts: impl Iterator<Item = (String, Option<Type>)>,
-        ) -> Self {
-            Type::from_stykind(STyKind::Union(
-                kts.map(|(k, t)| (k, t.map(|t| t.0))).collect(),
-            ))
-        }
-    }
-
-    impl super::de::sealed::Sealed for Type {}
-
-    impl super::de::Deserialize for Type {
-        fn from_dhall(v: &dhall::Value) -> super::de::Result<Self> {
-            let sty = v.to_simple_type().ok_or_else(|| {
-                Error::Deserialize(format!(
-                    "this cannot be deserialized into a simple type: {}",
-                    v
-                ))
-            })?;
-            Ok(Type(sty))
-        }
-    }
+/// A data structure that can be deserialized from a Dhall expression
+///
+/// This is automatically implemented for any type that [serde][serde]
+/// can deserialize.
+///
+/// This trait cannot be implemented manually.
+pub trait Deserialize: sealed::Sealed + Sized {
+    /// See [serde_dhall::from_str][crate::from_str]
+    fn from_dhall(v: &dhall::Value) -> Result<Self>;
 }
 
-/// Deserialize Dhall data to a Rust data structure.
-pub mod de {
-    use super::StaticType;
-    use super::Type;
-    pub use error::{Error, Result};
-
-    mod error {
-        use dhall::error::Error as DhallError;
-
-        pub type Result<T> = std::result::Result<T, Error>;
-
-        #[derive(Debug)]
-        #[non_exhaustive]
-        pub enum Error {
-            Dhall(DhallError),
-            Deserialize(String),
-        }
-
-        impl std::fmt::Display for Error {
-            fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
-                match self {
-                    Error::Dhall(err) => write!(f, "{}", err),
-                    Error::Deserialize(err) => write!(f, "{}", err),
-                }
-            }
-        }
-
-        impl std::error::Error for Error {}
-
-        impl serde::de::Error for Error {
-            fn custom<T>(msg: T) -> Self
-            where
-                T: std::fmt::Display,
-            {
-                Error::Deserialize(msg.to_string())
-            }
-        }
-    }
-
-    pub(crate) mod sealed {
-        pub trait Sealed {}
-    }
-
-    /// A data structure that can be deserialized from a Dhall expression
-    ///
-    /// This is automatically implemented for any type that [serde][serde]
-    /// can deserialize.
-    ///
-    /// This trait cannot be implemented manually.
-    pub trait Deserialize: sealed::Sealed + Sized {
-        /// See [serde_dhall::from_str][crate::from_str]
-        fn from_dhall(v: &dhall::Value) -> Result<Self>;
-    }
-
-    fn from_str_with_annot<T>(s: &str, ty: Option<&Type>) -> Result<T>
-    where
-        T: Deserialize,
-    {
-        let ty = ty.map(|ty| ty.to_dhall_value());
-        let val = dhall::Value::from_str_with_annot(s, ty.as_ref())
-            .map_err(Error::Dhall)?;
-        T::from_dhall(&val)
-    }
+fn from_str_with_annot<T>(s: &str, ty: Option<&Type>) -> Result<T>
+where
+    T: Deserialize,
+{
+    let ty = ty.map(|ty| ty.to_dhall_value());
+    let val = dhall::Value::from_str_with_annot(s, ty.as_ref())
+        .map_err(Error::Dhall)?;
+    T::from_dhall(&val)
+}
 
-    /// Deserialize an instance of type `T` from a string of Dhall text.
-    ///
-    /// This will recursively resolve all imports in the expression, and
-    /// typecheck it before deserialization. Relative imports will be resolved relative to the
-    /// provided file. More control over this process is not yet available
-    /// but will be in a coming version of this crate.
-    pub fn from_str<T>(s: &str) -> Result<T>
-    where
-        T: Deserialize,
-    {
-        from_str_with_annot(s, None)
-    }
+/// Deserialize an instance of type `T` from a string of Dhall text.
+///
+/// This will recursively resolve all imports in the expression, and
+/// typecheck it before deserialization. Relative imports will be resolved relative to the
+/// provided file. More control over this process is not yet available
+/// but will be in a coming version of this crate.
+pub fn from_str<T>(s: &str) -> Result<T>
+where
+    T: Deserialize,
+{
+    from_str_with_annot(s, None)
+}
 
-    /// Deserialize an instance of type `T` from a string of Dhall text,
-    /// additionally checking that it matches the supplied type.
-    ///
-    /// Like [from_str], but this additionally checks that
-    /// the type of the provided expression matches the supplied type.
-    pub fn from_str_check_type<T>(s: &str, ty: &Type) -> Result<T>
-    where
-        T: Deserialize,
-    {
-        from_str_with_annot(s, Some(ty))
-    }
+/// Deserialize an instance of type `T` from a string of Dhall text,
+/// additionally checking that it matches the supplied type.
+///
+/// Like [from_str], but this additionally checks that
+/// the type of the provided expression matches the supplied type.
+pub fn from_str_check_type<T>(s: &str, ty: &Type) -> Result<T>
+where
+    T: Deserialize,
+{
+    from_str_with_annot(s, Some(ty))
+}
 
-    /// Deserialize an instance of type `T` from a string of Dhall text,
-    /// additionally checking that it matches the type of `T`.
-    ///
-    /// Like [from_str], but this additionally checks that
-    /// the type of the provided expression matches the output type `T`. The [StaticType] trait
-    /// captures Rust types that are valid Dhall types.
-    pub fn from_str_auto_type<T>(s: &str) -> Result<T>
-    where
-        T: Deserialize + StaticType,
-    {
-        from_str_check_type(s, &<T as StaticType>::static_type())
-    }
+/// Deserialize an instance of type `T` from a string of Dhall text,
+/// additionally checking that it matches the type of `T`.
+///
+/// Like [from_str], but this additionally checks that
+/// the type of the provided expression matches the output type `T`. The [StaticType] trait
+/// captures Rust types that are valid Dhall types.
+pub fn from_str_auto_type<T>(s: &str) -> Result<T>
+where
+    T: Deserialize + StaticType,
+{
+    from_str_check_type(s, &<T as StaticType>::static_type())
 }
-- 
cgit v1.2.3


From fa89e9cb319b353332c9e835944e7f86a6604c42 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Wed, 18 Mar 2020 21:37:14 +0000
Subject: Move Value, SimpleValue and SimpleType to serde

---
 serde_dhall/src/lib.rs | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

(limited to 'serde_dhall/src/lib.rs')

diff --git a/serde_dhall/src/lib.rs b/serde_dhall/src/lib.rs
index 15f45ce..adc242f 100644
--- a/serde_dhall/src/lib.rs
+++ b/serde_dhall/src/lib.rs
@@ -171,11 +171,13 @@ mod error;
 mod serde;
 pub mod simple;
 mod static_type;
+mod value;
 
 #[doc(hidden)]
 pub use dhall_proc_macros::StaticType;
 pub use error::{Error, Result};
 pub use static_type::StaticType;
+pub use value::Value;
 
 use simple::Type;
 
@@ -191,16 +193,15 @@ pub(crate) mod sealed {
 /// This trait cannot be implemented manually.
 pub trait Deserialize: sealed::Sealed + Sized {
     /// See [serde_dhall::from_str][crate::from_str]
-    fn from_dhall(v: &dhall::Value) -> Result<Self>;
+    fn from_dhall(v: &Value) -> Result<Self>;
 }
 
 fn from_str_with_annot<T>(s: &str, ty: Option<&Type>) -> Result<T>
 where
     T: Deserialize,
 {
-    let ty = ty.map(|ty| ty.to_dhall_value());
-    let val = dhall::Value::from_str_with_annot(s, ty.as_ref())
-        .map_err(Error::Dhall)?;
+    let ty = ty.map(|ty| ty.to_value());
+    let val = Value::from_str_with_annot(s, ty.as_ref())?;
     T::from_dhall(&val)
 }
 
-- 
cgit v1.2.3


From a1f370cb68974c1e69f8f85345e91ec763b23ae2 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Wed, 18 Mar 2020 22:28:41 +0000
Subject: Expose simple::Val/Ty properly in the API

---
 serde_dhall/src/lib.rs | 31 ++++++++++++++++---------------
 1 file changed, 16 insertions(+), 15 deletions(-)

(limited to 'serde_dhall/src/lib.rs')

diff --git a/serde_dhall/src/lib.rs b/serde_dhall/src/lib.rs
index adc242f..4b1a689 100644
--- a/serde_dhall/src/lib.rs
+++ b/serde_dhall/src/lib.rs
@@ -16,7 +16,7 @@
 //!
 //! # Basic usage
 //!
-//! The main entrypoint of this library is the [`from_str`][from_str] function. It reads a string
+//! The main entrypoint of this library is the [`from_str`](fn.from_str.html) function. It reads a string
 //! containing a Dhall expression and deserializes it into any serde-compatible type.
 //!
 //! This could mean a common Rust type like `HashMap`:
@@ -88,11 +88,11 @@
 //!
 //! # Replacing `serde_json` or `serde_yaml`
 //!
-//! If you used to consume JSON or YAML, you only need to replace [serde_json::from_str] or
-//! [serde_yaml::from_str] with [serde_dhall::from_str][from_str].
+//! If you used to consume JSON or YAML, you only need to replace [`serde_json::from_str`] or
+//! [`serde_yaml::from_str`] with [`serde_dhall::from_str`](fn.from_str.html).
 //!
-//! [serde_json::from_str]: https://docs.serde.rs/serde_json/de/fn.from_str.html
-//! [serde_yaml::from_str]: https://docs.serde.rs/serde_yaml/fn.from_str.html
+//! [`serde_json::from_str`]: https://docs.serde.rs/serde_json/fn.from_str.html
+//! [`serde_yaml::from_str`]: https://docs.serde.rs/serde_yaml/fn.from_str.html
 //!
 //!
 //! # Additional Dhall typechecking
@@ -106,8 +106,8 @@
 //! There are two ways to typecheck a Dhall value: you can provide the type as Dhall text or you
 //! can let Rust infer it for you.
 //!
-//! To provide a type written in Dhall, first parse it into a [`serde_dhall::Type`][Type], then
-//! pass it to [`from_str_check_type`][from_str_check_type].
+//! To provide a type written in Dhall, first parse it into a [`simple::Type`](simple/struct.Type.html), then
+//! pass it to [`from_str_check_type`](fn.from_str_check_type.html).
 //!
 //! ```rust
 //! # fn main() -> serde_dhall::Result<()> {
@@ -135,7 +135,8 @@
 //! # }
 //! ```
 //!
-//! You can also let Rust infer the appropriate Dhall type, using the [StaticType] trait.
+//! You can also let Rust infer the appropriate Dhall type, using the
+//! [StaticType](trait.StaticType.html) trait.
 //!
 //! ```rust
 //! # fn main() -> serde_dhall::Result<()> {
@@ -169,18 +170,19 @@
 
 mod error;
 mod serde;
+/// Serde-compatible values and their type
 pub mod simple;
 mod static_type;
-mod value;
+/// Arbitrary Dhall values
+pub mod value;
 
+pub use crate::simple::{Type as SimpleType, Value as SimpleValue};
 #[doc(hidden)]
 pub use dhall_proc_macros::StaticType;
 pub use error::{Error, Result};
 pub use static_type::StaticType;
 pub use value::Value;
 
-use simple::Type;
-
 pub(crate) mod sealed {
     pub trait Sealed {}
 }
@@ -196,12 +198,11 @@ pub trait Deserialize: sealed::Sealed + Sized {
     fn from_dhall(v: &Value) -> Result<Self>;
 }
 
-fn from_str_with_annot<T>(s: &str, ty: Option<&Type>) -> Result<T>
+fn from_str_with_annot<T>(s: &str, ty: Option<&simple::Type>) -> Result<T>
 where
     T: Deserialize,
 {
-    let ty = ty.map(|ty| ty.to_value());
-    let val = Value::from_str_with_annot(s, ty.as_ref())?;
+    let val = Value::from_str_with_annot(s, ty)?;
     T::from_dhall(&val)
 }
 
@@ -223,7 +224,7 @@ where
 ///
 /// Like [from_str], but this additionally checks that
 /// the type of the provided expression matches the supplied type.
-pub fn from_str_check_type<T>(s: &str, ty: &Type) -> Result<T>
+pub fn from_str_check_type<T>(s: &str, ty: &simple::Type) -> Result<T>
 where
     T: Deserialize,
 {
-- 
cgit v1.2.3


From 85e2e8ee5e83dadd05b6974ba6c951350cb97a61 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Sat, 21 Mar 2020 21:30:30 +0000
Subject: Introduce option builder

---
 serde_dhall/src/lib.rs | 16 +++++-----------
 1 file changed, 5 insertions(+), 11 deletions(-)

(limited to 'serde_dhall/src/lib.rs')

diff --git a/serde_dhall/src/lib.rs b/serde_dhall/src/lib.rs
index 4b1a689..5b8f470 100644
--- a/serde_dhall/src/lib.rs
+++ b/serde_dhall/src/lib.rs
@@ -169,6 +169,8 @@
 //! [serde::Deserialize]: https://docs.serde.rs/serde/trait.Deserialize.html
 
 mod error;
+/// Finer-grained control over deserializing Dhall
+pub mod options;
 mod serde;
 /// Serde-compatible values and their type
 pub mod simple;
@@ -198,14 +200,6 @@ pub trait Deserialize: sealed::Sealed + Sized {
     fn from_dhall(v: &Value) -> Result<Self>;
 }
 
-fn from_str_with_annot<T>(s: &str, ty: Option<&simple::Type>) -> Result<T>
-where
-    T: Deserialize,
-{
-    let val = Value::from_str_with_annot(s, ty)?;
-    T::from_dhall(&val)
-}
-
 /// Deserialize an instance of type `T` from a string of Dhall text.
 ///
 /// This will recursively resolve all imports in the expression, and
@@ -216,7 +210,7 @@ pub fn from_str<T>(s: &str) -> Result<T>
 where
     T: Deserialize,
 {
-    from_str_with_annot(s, None)
+    options::from_str(s).parse()
 }
 
 /// Deserialize an instance of type `T` from a string of Dhall text,
@@ -228,7 +222,7 @@ pub fn from_str_check_type<T>(s: &str, ty: &simple::Type) -> Result<T>
 where
     T: Deserialize,
 {
-    from_str_with_annot(s, Some(ty))
+    options::from_str(s).type_annotation(ty).parse()
 }
 
 /// Deserialize an instance of type `T` from a string of Dhall text,
@@ -241,5 +235,5 @@ pub fn from_str_auto_type<T>(s: &str) -> Result<T>
 where
     T: Deserialize + StaticType,
 {
-    from_str_check_type(s, &<T as StaticType>::static_type())
+    options::from_str(s).static_type_annotation().parse()
 }
-- 
cgit v1.2.3


From b0ee39b006ad2ca99bd3dddf06ab0e0dcc966d2f Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Sat, 21 Mar 2020 21:42:54 +0000
Subject: Test README code samples using doc_comment

---
 serde_dhall/src/lib.rs | 3 +++
 1 file changed, 3 insertions(+)

(limited to 'serde_dhall/src/lib.rs')

diff --git a/serde_dhall/src/lib.rs b/serde_dhall/src/lib.rs
index 5b8f470..4250882 100644
--- a/serde_dhall/src/lib.rs
+++ b/serde_dhall/src/lib.rs
@@ -168,6 +168,9 @@
 //! [serde]: https://docs.serde.rs/serde/
 //! [serde::Deserialize]: https://docs.serde.rs/serde/trait.Deserialize.html
 
+#[cfg(doctest)]
+doc_comment::doctest!("../../README.md");
+
 mod error;
 /// Finer-grained control over deserializing Dhall
 pub mod options;
-- 
cgit v1.2.3


From 1a98b506055779e1a60558d9c5a56b071b3d61a0 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Sun, 22 Mar 2020 21:20:58 +0000
Subject: Reorganize API and internals of serde_dhall a bit

---
 serde_dhall/src/lib.rs | 80 ++++++++++++--------------------------------------
 1 file changed, 18 insertions(+), 62 deletions(-)

(limited to 'serde_dhall/src/lib.rs')

diff --git a/serde_dhall/src/lib.rs b/serde_dhall/src/lib.rs
index 4250882..5ee1cf6 100644
--- a/serde_dhall/src/lib.rs
+++ b/serde_dhall/src/lib.rs
@@ -1,4 +1,6 @@
 #![doc(html_root_url = "https://docs.rs/serde_dhall/0.4.0")]
+// #![warn(missing_docs)]
+// #![warn(missing_doc_code_examples)]
 //! [Dhall][dhall] is a programmable configuration language that provides a non-repetitive
 //! alternative to JSON and YAML.
 //!
@@ -107,7 +109,7 @@
 //! can let Rust infer it for you.
 //!
 //! To provide a type written in Dhall, first parse it into a [`simple::Type`](simple/struct.Type.html), then
-//! pass it to [`from_str_check_type`](fn.from_str_check_type.html).
+//! pass it to [`from_str_manual_type`](fn.from_str_manual_type.html).
 //!
 //! ```rust
 //! # fn main() -> serde_dhall::Result<()> {
@@ -124,7 +126,7 @@
 //! // Deserialize the data to a Rust type. This checks that
 //! // the data matches the provided type.
 //! let deserialized_map: HashMap<String, usize> =
-//!         serde_dhall::from_str_check_type(point_data, &point_type)?;
+//!         serde_dhall::from_str_manual_type(point_data, &point_type)?;
 //!
 //! let mut expected_map = HashMap::new();
 //! expected_map.insert("x".to_string(), 1);
@@ -153,13 +155,13 @@
 //! let data = "{ x = 1, y = 1 + 1 }";
 //!
 //! // Convert the Dhall string to a Point.
-//! let point: Point = serde_dhall::from_str_auto_type(data)?;
+//! let point: Point = serde_dhall::from_str_static_type(data)?;
 //! assert_eq!(point.x, 1);
 //! assert_eq!(point.y, 2);
 //!
 //! // Invalid data fails the type validation
 //! let invalid_data = "{ x = 1, z = 0.3 }";
-//! assert!(serde_dhall::from_str_auto_type::<Point>(invalid_data).is_err());
+//! assert!(serde_dhall::from_str_static_type::<Point>(invalid_data).is_err());
 //! # Ok(())
 //! # }
 //! ```
@@ -171,72 +173,26 @@
 #[cfg(doctest)]
 doc_comment::doctest!("../../README.md");
 
-mod error;
 /// Finer-grained control over deserializing Dhall
 pub mod options;
-mod serde;
-/// Serde-compatible values and their type
+/// Serde-compatible Dhall values and their type
 pub mod simple;
-mod static_type;
 /// Arbitrary Dhall values
 pub mod value;
 
-pub use crate::simple::{Type as SimpleType, Value as SimpleValue};
+mod deserialize;
+mod error;
+/// Common patterns made easier
+mod shortcuts;
+mod static_type;
+
 #[doc(hidden)]
 pub use dhall_proc_macros::StaticType;
+
+pub use deserialize::Deserialize;
+pub(crate) use deserialize::Sealed;
 pub use error::{Error, Result};
+pub use shortcuts::{from_str, from_str_manual_type, from_str_static_type};
+pub use simple::{Type as SimpleType, Value as SimpleValue};
 pub use static_type::StaticType;
 pub use value::Value;
-
-pub(crate) mod sealed {
-    pub trait Sealed {}
-}
-
-/// A data structure that can be deserialized from a Dhall expression
-///
-/// This is automatically implemented for any type that [serde][serde]
-/// can deserialize.
-///
-/// This trait cannot be implemented manually.
-pub trait Deserialize: sealed::Sealed + Sized {
-    /// See [serde_dhall::from_str][crate::from_str]
-    fn from_dhall(v: &Value) -> Result<Self>;
-}
-
-/// Deserialize an instance of type `T` from a string of Dhall text.
-///
-/// This will recursively resolve all imports in the expression, and
-/// typecheck it before deserialization. Relative imports will be resolved relative to the
-/// provided file. More control over this process is not yet available
-/// but will be in a coming version of this crate.
-pub fn from_str<T>(s: &str) -> Result<T>
-where
-    T: Deserialize,
-{
-    options::from_str(s).parse()
-}
-
-/// Deserialize an instance of type `T` from a string of Dhall text,
-/// additionally checking that it matches the supplied type.
-///
-/// Like [from_str], but this additionally checks that
-/// the type of the provided expression matches the supplied type.
-pub fn from_str_check_type<T>(s: &str, ty: &simple::Type) -> Result<T>
-where
-    T: Deserialize,
-{
-    options::from_str(s).type_annotation(ty).parse()
-}
-
-/// Deserialize an instance of type `T` from a string of Dhall text,
-/// additionally checking that it matches the type of `T`.
-///
-/// Like [from_str], but this additionally checks that
-/// the type of the provided expression matches the output type `T`. The [StaticType] trait
-/// captures Rust types that are valid Dhall types.
-pub fn from_str_auto_type<T>(s: &str) -> Result<T>
-where
-    T: Deserialize + StaticType,
-{
-    options::from_str(s).static_type_annotation().parse()
-}
-- 
cgit v1.2.3


From 002d7c2a74647312a821598ac3d9f5521296873d Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Sun, 22 Mar 2020 21:25:44 +0000
Subject: Add a bunch of TODOs

---
 serde_dhall/src/lib.rs | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

(limited to 'serde_dhall/src/lib.rs')

diff --git a/serde_dhall/src/lib.rs b/serde_dhall/src/lib.rs
index 5ee1cf6..e59255c 100644
--- a/serde_dhall/src/lib.rs
+++ b/serde_dhall/src/lib.rs
@@ -1,6 +1,5 @@
 #![doc(html_root_url = "https://docs.rs/serde_dhall/0.4.0")]
-// #![warn(missing_docs)]
-// #![warn(missing_doc_code_examples)]
+// TODO #![warn(missing_docs)] #![warn(missing_doc_code_examples)]
 //! [Dhall][dhall] is a programmable configuration language that provides a non-repetitive
 //! alternative to JSON and YAML.
 //!
@@ -173,7 +172,7 @@
 #[cfg(doctest)]
 doc_comment::doctest!("../../README.md");
 
-/// Finer-grained control over deserializing Dhall
+/// Finer-grained control over deserializing Dhall values
 pub mod options;
 /// Serde-compatible Dhall values and their type
 pub mod simple;
-- 
cgit v1.2.3


From fd4a81b1a92c1859941538b7f2212c621f4b43fd Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Sun, 22 Mar 2020 21:29:36 +0000
Subject: Hide SimpleValue from api

---
 serde_dhall/src/lib.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'serde_dhall/src/lib.rs')

diff --git a/serde_dhall/src/lib.rs b/serde_dhall/src/lib.rs
index e59255c..19d3f7e 100644
--- a/serde_dhall/src/lib.rs
+++ b/serde_dhall/src/lib.rs
@@ -174,7 +174,7 @@ doc_comment::doctest!("../../README.md");
 
 /// Finer-grained control over deserializing Dhall values
 pub mod options;
-/// Serde-compatible Dhall values and their type
+/// Serde-compatible Dhall types
 pub mod simple;
 /// Arbitrary Dhall values
 pub mod value;
@@ -192,6 +192,6 @@ pub use deserialize::Deserialize;
 pub(crate) use deserialize::Sealed;
 pub use error::{Error, Result};
 pub use shortcuts::{from_str, from_str_manual_type, from_str_static_type};
-pub use simple::{Type as SimpleType, Value as SimpleValue};
+pub use simple::{Type as SimpleType};
 pub use static_type::StaticType;
 pub use value::Value;
-- 
cgit v1.2.3


From a70922c6c6beb58a45da80f15576b54fb915ec28 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Sun, 22 Mar 2020 22:11:00 +0000
Subject: Rework SimpleType

---
 serde_dhall/src/lib.rs | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

(limited to 'serde_dhall/src/lib.rs')

diff --git a/serde_dhall/src/lib.rs b/serde_dhall/src/lib.rs
index 19d3f7e..8780682 100644
--- a/serde_dhall/src/lib.rs
+++ b/serde_dhall/src/lib.rs
@@ -107,17 +107,17 @@
 //! There are two ways to typecheck a Dhall value: you can provide the type as Dhall text or you
 //! can let Rust infer it for you.
 //!
-//! To provide a type written in Dhall, first parse it into a [`simple::Type`](simple/struct.Type.html), then
+//! To provide a type written in Dhall, first parse it into a [`SimpleType`](enum.SimpleType.html), then
 //! pass it to [`from_str_manual_type`](fn.from_str_manual_type.html).
 //!
 //! ```rust
 //! # fn main() -> serde_dhall::Result<()> {
-//! use serde_dhall::simple::Type;
+//! use serde_dhall::SimpleType;
 //! use std::collections::HashMap;
 //!
 //! // Parse a Dhall type
 //! let point_type_str = "{ x: Natural, y: Natural }";
-//! let point_type: Type = serde_dhall::from_str(point_type_str)?;
+//! let point_type: SimpleType = serde_dhall::from_str(point_type_str)?;
 //!
 //! // Some Dhall data
 //! let point_data = "{ x = 1, y = 1 + 1 }";
@@ -174,8 +174,6 @@ doc_comment::doctest!("../../README.md");
 
 /// Finer-grained control over deserializing Dhall values
 pub mod options;
-/// Serde-compatible Dhall types
-pub mod simple;
 /// Arbitrary Dhall values
 pub mod value;
 
@@ -183,6 +181,8 @@ mod deserialize;
 mod error;
 /// Common patterns made easier
 mod shortcuts;
+/// Serde-compatible Dhall types
+mod simple;
 mod static_type;
 
 #[doc(hidden)]
@@ -192,6 +192,6 @@ pub use deserialize::Deserialize;
 pub(crate) use deserialize::Sealed;
 pub use error::{Error, Result};
 pub use shortcuts::{from_str, from_str_manual_type, from_str_static_type};
-pub use simple::{Type as SimpleType};
+pub use simple::SimpleType;
 pub use static_type::StaticType;
 pub use value::Value;
-- 
cgit v1.2.3


From 263fbebda7bc3c0f8c4497e1e508125ca91382f1 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Sun, 22 Mar 2020 22:22:46 +0000
Subject: Hide Value from API

---
 serde_dhall/src/lib.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'serde_dhall/src/lib.rs')

diff --git a/serde_dhall/src/lib.rs b/serde_dhall/src/lib.rs
index 8780682..c6c6bf9 100644
--- a/serde_dhall/src/lib.rs
+++ b/serde_dhall/src/lib.rs
@@ -174,8 +174,6 @@ doc_comment::doctest!("../../README.md");
 
 /// Finer-grained control over deserializing Dhall values
 pub mod options;
-/// Arbitrary Dhall values
-pub mod value;
 
 mod deserialize;
 mod error;
@@ -184,6 +182,8 @@ mod shortcuts;
 /// Serde-compatible Dhall types
 mod simple;
 mod static_type;
+/// Dhall values
+mod value;
 
 #[doc(hidden)]
 pub use dhall_proc_macros::StaticType;
-- 
cgit v1.2.3


From 3a5f2044954aae7278f16e30561a81626dba6923 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Sun, 22 Mar 2020 22:27:56 +0000
Subject: Move mod simple into value

---
 serde_dhall/src/lib.rs | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

(limited to 'serde_dhall/src/lib.rs')

diff --git a/serde_dhall/src/lib.rs b/serde_dhall/src/lib.rs
index c6c6bf9..02b34a7 100644
--- a/serde_dhall/src/lib.rs
+++ b/serde_dhall/src/lib.rs
@@ -179,8 +179,6 @@ mod deserialize;
 mod error;
 /// Common patterns made easier
 mod shortcuts;
-/// Serde-compatible Dhall types
-mod simple;
 mod static_type;
 /// Dhall values
 mod value;
@@ -192,6 +190,5 @@ pub use deserialize::Deserialize;
 pub(crate) use deserialize::Sealed;
 pub use error::{Error, Result};
 pub use shortcuts::{from_str, from_str_manual_type, from_str_static_type};
-pub use simple::SimpleType;
 pub use static_type::StaticType;
-pub use value::Value;
+pub use value::{SimpleType, Value};
-- 
cgit v1.2.3


From 8e74abfc55f86dbd9142a9f38e070d2583454ddd Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Mon, 23 Mar 2020 22:30:48 +0000
Subject: Go mad with doc macros

---
 serde_dhall/src/lib.rs | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

(limited to 'serde_dhall/src/lib.rs')

diff --git a/serde_dhall/src/lib.rs b/serde_dhall/src/lib.rs
index 02b34a7..4cb25e5 100644
--- a/serde_dhall/src/lib.rs
+++ b/serde_dhall/src/lib.rs
@@ -189,6 +189,9 @@ pub use dhall_proc_macros::StaticType;
 pub use deserialize::Deserialize;
 pub(crate) use deserialize::Sealed;
 pub use error::{Error, Result};
-pub use shortcuts::{from_str, from_str_manual_type, from_str_static_type};
+pub use shortcuts::{
+    from_file, from_file_manual_type, from_file_static_type, from_str,
+    from_str_manual_type, from_str_static_type,
+};
 pub use static_type::StaticType;
 pub use value::{SimpleType, Value};
-- 
cgit v1.2.3


From f9848b54fe2e64901042fba66fb471999f415ff1 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Tue, 24 Mar 2020 18:53:25 +0000
Subject: Hide serde Error internals

---
 serde_dhall/src/lib.rs | 1 +
 1 file changed, 1 insertion(+)

(limited to 'serde_dhall/src/lib.rs')

diff --git a/serde_dhall/src/lib.rs b/serde_dhall/src/lib.rs
index 4cb25e5..fe1f4b2 100644
--- a/serde_dhall/src/lib.rs
+++ b/serde_dhall/src/lib.rs
@@ -188,6 +188,7 @@ pub use dhall_proc_macros::StaticType;
 
 pub use deserialize::Deserialize;
 pub(crate) use deserialize::Sealed;
+pub(crate) use error::ErrorKind;
 pub use error::{Error, Result};
 pub use shortcuts::{
     from_file, from_file_manual_type, from_file_static_type, from_str,
-- 
cgit v1.2.3


From 060c835db9638556763b98cfcf7c4be196653644 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Tue, 24 Mar 2020 19:42:48 +0000
Subject: More doc

---
 serde_dhall/src/lib.rs | 102 +++++++++++++++++++++----------------------------
 1 file changed, 44 insertions(+), 58 deletions(-)

(limited to 'serde_dhall/src/lib.rs')

diff --git a/serde_dhall/src/lib.rs b/serde_dhall/src/lib.rs
index fe1f4b2..71274b6 100644
--- a/serde_dhall/src/lib.rs
+++ b/serde_dhall/src/lib.rs
@@ -1,5 +1,5 @@
 #![doc(html_root_url = "https://docs.rs/serde_dhall/0.4.0")]
-// TODO #![warn(missing_docs)] #![warn(missing_doc_code_examples)]
+#![warn(missing_docs, missing_doc_code_examples)]
 //! [Dhall][dhall] is a programmable configuration language that provides a non-repetitive
 //! alternative to JSON and YAML.
 //!
@@ -47,7 +47,7 @@
 //! # fn main() -> serde_dhall::Result<()> {
 //! use serde::Deserialize;
 //!
-//! #[derive(Debug, Deserialize)]
+//! #[derive(Deserialize)]
 //! struct Point {
 //!     x: u64,
 //!     y: u64,
@@ -65,28 +65,6 @@
 //! # }
 //! ```
 //!
-//! # 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<T>`
-//! `Optional T`  | `Option<T>`
-//! `{ x: T, y: U }`  | structs
-//! `{ _1: T, _2: U }`  | `(T, U)`, structs
-//! `{ x: T, y: T }`  | `HashMap<String, T>`, structs
-//! `< x: T \| y: U >`  | enums
-//! `T -> U`  | unsupported
-//! `Prelude.JSON.Type`  | unsupported
-//! `Prelude.Map.Type T U`  | unsupported
-//!
-//!
 //! # Replacing `serde_json` or `serde_yaml`
 //!
 //! If you used to consume JSON or YAML, you only need to replace [`serde_json::from_str`] or
@@ -99,16 +77,45 @@
 //! # Additional Dhall typechecking
 //!
 //! When deserializing, normal type checking is done to ensure that the returned value is a valid
-//! Dhall value, and that it can be deserialized into the required Rust type. However types are
-//! first-class in Dhall, and this library allows you to additionally check that some input data
+//! Dhall value. However types are
+//! first-class in Dhall, and this library allows you to additionally check that the input data
 //! matches a given Dhall type. That way, a type error will be caught on the Dhall side, and have
 //! pretty and explicit errors that point to the source file.
 //!
-//! There are two ways to typecheck a Dhall value: you can provide the type as Dhall text or you
-//! can let Rust infer it for you.
+//! There are two ways to typecheck a Dhall value in this way: you can provide the type manually or
+//! you can let Rust infer it for you.
+//!
+//! To let Rust infer the appropriate Dhall type, use the [StaticType](trait.StaticType.html)
+//! trait.
+//!
+//! ```rust
+//! # fn main() -> serde_dhall::Result<()> {
+//! use serde::Deserialize;
+//! use serde_dhall::StaticType;
+//!
+//! #[derive(Deserialize, StaticType)]
+//! struct Point {
+//!     x: u64,
+//!     y: u64,
+//! }
+//!
+//! // Some Dhall data
+//! let data = "{ x = 1, y = 1 + 1 }";
+//!
+//! // Convert the Dhall string to a Point.
+//! let point: Point = serde_dhall::from_str_static_type(data)?;
+//! assert_eq!(point.x, 1);
+//! assert_eq!(point.y, 2);
+//!
+//! // Invalid data fails the type validation
+//! let invalid_data = "{ x = 1, z = 0.3 }";
+//! assert!(serde_dhall::from_str_static_type::<Point>(invalid_data).is_err());
+//! # Ok(())
+//! # }
+//! ```
 //!
-//! To provide a type written in Dhall, first parse it into a [`SimpleType`](enum.SimpleType.html), then
-//! pass it to [`from_str_manual_type`](fn.from_str_manual_type.html).
+//! To provide a type manually, you need a [`SimpleType`](enum.SimpleType.html) value. You
+//! can parse it from some Dhall text like you would parse any other value.
 //!
 //! ```rust
 //! # fn main() -> serde_dhall::Result<()> {
@@ -136,41 +143,20 @@
 //! # }
 //! ```
 //!
-//! You can also let Rust infer the appropriate Dhall type, using the
-//! [StaticType](trait.StaticType.html) trait.
-//!
-//! ```rust
-//! # fn main() -> serde_dhall::Result<()> {
-//! use serde::Deserialize;
-//! use serde_dhall::StaticType;
-//!
-//! #[derive(Debug, Deserialize, StaticType)]
-//! struct Point {
-//!     x: u64,
-//!     y: u64,
-//! }
+//! # Controlling deserialization
 //!
-//! // Some Dhall data
-//! let data = "{ x = 1, y = 1 + 1 }";
-//!
-//! // Convert the Dhall string to a Point.
-//! let point: Point = serde_dhall::from_str_static_type(data)?;
-//! assert_eq!(point.x, 1);
-//! assert_eq!(point.y, 2);
-//!
-//! // Invalid data fails the type validation
-//! let invalid_data = "{ x = 1, z = 0.3 }";
-//! assert!(serde_dhall::from_str_static_type::<Point>(invalid_data).is_err());
-//! # Ok(())
-//! # }
-//! ```
+//! If you need more control over the process of reading Dhall values, e.g. disabling
+//! imports, see the [`options`] module.
 //!
+//! [`options`]: options/index.html
 //! [dhall]: https://dhall-lang.org/
 //! [serde]: https://docs.serde.rs/serde/
 //! [serde::Deserialize]: https://docs.serde.rs/serde/trait.Deserialize.html
 
 #[cfg(doctest)]
-doc_comment::doctest!("../../README.md");
+mod test_readme {
+    doc_comment::doctest!("../../README.md");
+}
 
 /// Finer-grained control over deserializing Dhall values
 pub mod options;
-- 
cgit v1.2.3


From 15a0902b50ff6d1b36dbf7a220b6ff42ceefada6 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Sun, 5 Apr 2020 11:43:22 +0100
Subject: Rename Deserialize trait to FromDhall

---
 serde_dhall/src/lib.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'serde_dhall/src/lib.rs')

diff --git a/serde_dhall/src/lib.rs b/serde_dhall/src/lib.rs
index 71274b6..9f99adb 100644
--- a/serde_dhall/src/lib.rs
+++ b/serde_dhall/src/lib.rs
@@ -172,7 +172,7 @@ mod value;
 #[doc(hidden)]
 pub use dhall_proc_macros::StaticType;
 
-pub use deserialize::Deserialize;
+pub use deserialize::FromDhall;
 pub(crate) use deserialize::Sealed;
 pub(crate) use error::ErrorKind;
 pub use error::{Error, Result};
-- 
cgit v1.2.3


From 678d254a06dbb75f5398abaacee41d1712bf7194 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Sun, 5 Apr 2020 15:53:15 +0100
Subject: Make Deserializer functions the only functions

---
 serde_dhall/src/lib.rs | 25 ++++++++++---------------
 1 file changed, 10 insertions(+), 15 deletions(-)

(limited to 'serde_dhall/src/lib.rs')

diff --git a/serde_dhall/src/lib.rs b/serde_dhall/src/lib.rs
index 9f99adb..8ad7cb3 100644
--- a/serde_dhall/src/lib.rs
+++ b/serde_dhall/src/lib.rs
@@ -30,7 +30,7 @@
 //! let data = "{ x = 1, y = 1 + 1 } : { x: Natural, y: Natural }";
 //!
 //! // Deserialize it to a Rust type.
-//! let deserialized_map: HashMap<String, usize> = serde_dhall::from_str(data)?;
+//! let deserialized_map: HashMap<String, usize> = serde_dhall::from_str(data).parse()?;
 //!
 //! let mut expected_map = HashMap::new();
 //! expected_map.insert("x".to_string(), 1);
@@ -57,7 +57,7 @@
 //! let data = "{ x = 1, y = 1 + 1 } : { x: Natural, y: Natural }";
 //!
 //! // Convert the Dhall string to a Point.
-//! let point: Point = serde_dhall::from_str(data)?;
+//! let point: Point = serde_dhall::from_str(data).parse()?;
 //! assert_eq!(point.x, 1);
 //! assert_eq!(point.y, 2);
 //!
@@ -68,7 +68,7 @@
 //! # Replacing `serde_json` or `serde_yaml`
 //!
 //! If you used to consume JSON or YAML, you only need to replace [`serde_json::from_str`] or
-//! [`serde_yaml::from_str`] with [`serde_dhall::from_str`](fn.from_str.html).
+//! [`serde_yaml::from_str`] with [`serde_dhall::from_str(…).parse()`](fn.from_str.html).
 //!
 //! [`serde_json::from_str`]: https://docs.serde.rs/serde_json/fn.from_str.html
 //! [`serde_yaml::from_str`]: https://docs.serde.rs/serde_yaml/fn.from_str.html
@@ -103,13 +103,13 @@
 //! let data = "{ x = 1, y = 1 + 1 }";
 //!
 //! // Convert the Dhall string to a Point.
-//! let point: Point = serde_dhall::from_str_static_type(data)?;
+//! let point: Point = serde_dhall::from_str(data).static_type_annotation().parse()?;
 //! assert_eq!(point.x, 1);
 //! assert_eq!(point.y, 2);
 //!
 //! // Invalid data fails the type validation
 //! let invalid_data = "{ x = 1, z = 0.3 }";
-//! assert!(serde_dhall::from_str_static_type::<Point>(invalid_data).is_err());
+//! assert!(serde_dhall::from_str::<Point>(invalid_data).static_type_annotation().parse().is_err());
 //! # Ok(())
 //! # }
 //! ```
@@ -124,7 +124,7 @@
 //!
 //! // Parse a Dhall type
 //! let point_type_str = "{ x: Natural, y: Natural }";
-//! let point_type: SimpleType = serde_dhall::from_str(point_type_str)?;
+//! let point_type: SimpleType = serde_dhall::from_str(point_type_str).parse()?;
 //!
 //! // Some Dhall data
 //! let point_data = "{ x = 1, y = 1 + 1 }";
@@ -132,7 +132,7 @@
 //! // Deserialize the data to a Rust type. This checks that
 //! // the data matches the provided type.
 //! let deserialized_map: HashMap<String, usize> =
-//!         serde_dhall::from_str_manual_type(point_data, &point_type)?;
+//!         serde_dhall::from_str(point_data).type_annotation(&point_type).parse()?;
 //!
 //! let mut expected_map = HashMap::new();
 //! expected_map.insert("x".to_string(), 1);
@@ -158,13 +158,9 @@ mod test_readme {
     doc_comment::doctest!("../../README.md");
 }
 
-/// Finer-grained control over deserializing Dhall values
-pub mod options;
-
+mod options;
 mod deserialize;
 mod error;
-/// Common patterns made easier
-mod shortcuts;
 mod static_type;
 /// Dhall values
 mod value;
@@ -176,9 +172,8 @@ pub use deserialize::FromDhall;
 pub(crate) use deserialize::Sealed;
 pub(crate) use error::ErrorKind;
 pub use error::{Error, Result};
-pub use shortcuts::{
-    from_file, from_file_manual_type, from_file_static_type, from_str,
-    from_str_manual_type, from_str_static_type,
+pub use options::{
+    from_file, from_str, Deserializer
 };
 pub use static_type::StaticType;
 pub use value::{SimpleType, Value};
-- 
cgit v1.2.3


From 797241ebec5cec686056b5da73864db8eab03d48 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Sun, 5 Apr 2020 16:36:54 +0100
Subject: Rewrite builder with state machine to allow parse::<>

---
 serde_dhall/src/lib.rs | 24 +++++++++++++++---------
 1 file changed, 15 insertions(+), 9 deletions(-)

(limited to 'serde_dhall/src/lib.rs')

diff --git a/serde_dhall/src/lib.rs b/serde_dhall/src/lib.rs
index 8ad7cb3..08ca4a5 100644
--- a/serde_dhall/src/lib.rs
+++ b/serde_dhall/src/lib.rs
@@ -103,13 +103,20 @@
 //! let data = "{ x = 1, y = 1 + 1 }";
 //!
 //! // Convert the Dhall string to a Point.
-//! let point: Point = serde_dhall::from_str(data).static_type_annotation().parse()?;
+//! let point = serde_dhall::from_str(data)
+//!     .static_type_annotation()
+//!     .parse::<Point>()?;
 //! assert_eq!(point.x, 1);
 //! assert_eq!(point.y, 2);
 //!
 //! // Invalid data fails the type validation
 //! let invalid_data = "{ x = 1, z = 0.3 }";
-//! assert!(serde_dhall::from_str::<Point>(invalid_data).static_type_annotation().parse().is_err());
+//! assert!(
+//!     serde_dhall::from_str(invalid_data)
+//!         .static_type_annotation()
+//!         .parse::<Point>()
+//!         .is_err()
+//! );
 //! # Ok(())
 //! # }
 //! ```
@@ -124,15 +131,16 @@
 //!
 //! // Parse a Dhall type
 //! let point_type_str = "{ x: Natural, y: Natural }";
-//! let point_type: SimpleType = serde_dhall::from_str(point_type_str).parse()?;
+//! let point_type = serde_dhall::from_str(point_type_str).parse::<SimpleType>()?;
 //!
 //! // Some Dhall data
 //! let point_data = "{ x = 1, y = 1 + 1 }";
 //!
 //! // Deserialize the data to a Rust type. This checks that
 //! // the data matches the provided type.
-//! let deserialized_map: HashMap<String, usize> =
-//!         serde_dhall::from_str(point_data).type_annotation(&point_type).parse()?;
+//! let deserialized_map = serde_dhall::from_str(point_data)
+//!     .type_annotation(&point_type)
+//!     .parse::<HashMap<String, usize>>()?;
 //!
 //! let mut expected_map = HashMap::new();
 //! expected_map.insert("x".to_string(), 1);
@@ -158,9 +166,9 @@ mod test_readme {
     doc_comment::doctest!("../../README.md");
 }
 
-mod options;
 mod deserialize;
 mod error;
+mod options;
 mod static_type;
 /// Dhall values
 mod value;
@@ -172,8 +180,6 @@ pub use deserialize::FromDhall;
 pub(crate) use deserialize::Sealed;
 pub(crate) use error::ErrorKind;
 pub use error::{Error, Result};
-pub use options::{
-    from_file, from_str, Deserializer
-};
+pub use options::{from_file, from_str, Deserializer};
 pub use static_type::StaticType;
 pub use value::{SimpleType, Value};
-- 
cgit v1.2.3


From c4d9e73126131d31e707822b0fd8b0710363c863 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Sun, 5 Apr 2020 17:12:08 +0100
Subject: Final doc tweaks

---
 serde_dhall/src/lib.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'serde_dhall/src/lib.rs')

diff --git a/serde_dhall/src/lib.rs b/serde_dhall/src/lib.rs
index 08ca4a5..c478b2a 100644
--- a/serde_dhall/src/lib.rs
+++ b/serde_dhall/src/lib.rs
@@ -154,9 +154,9 @@
 //! # Controlling deserialization
 //!
 //! If you need more control over the process of reading Dhall values, e.g. disabling
-//! imports, see the [`options`] module.
+//! imports, see the [`Deserializer`] methods.
 //!
-//! [`options`]: options/index.html
+//! [`Deserializer`]: struct.Deserializer.html
 //! [dhall]: https://dhall-lang.org/
 //! [serde]: https://docs.serde.rs/serde/
 //! [serde::Deserialize]: https://docs.serde.rs/serde/trait.Deserialize.html
-- 
cgit v1.2.3