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/tests/traits.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'serde_dhall/tests/traits.rs')

diff --git a/serde_dhall/tests/traits.rs b/serde_dhall/tests/traits.rs
index 15a91ed..b2fe6e5 100644
--- a/serde_dhall/tests/traits.rs
+++ b/serde_dhall/tests/traits.rs
@@ -1,8 +1,8 @@
-use serde_dhall::{from_str, StaticType, Value};
+use serde_dhall::{from_str, StaticType, Type};
 
 #[test]
 fn test_static_type() {
-    fn parse(s: &str) -> Value {
+    fn parse(s: &str) -> Type {
         from_str(s).unwrap()
     }
 
-- 
cgit v1.3.1


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

---
 dhall_proc_macros/src/derive.rs |   6 +-
 serde_dhall/src/error.rs        |  30 +++++
 serde_dhall/src/lib.rs          | 264 ++++++++++------------------------------
 serde_dhall/src/serde.rs        |   4 +-
 serde_dhall/src/simple.rs       |  81 ++++++++++++
 serde_dhall/tests/de.rs         |   4 +-
 serde_dhall/tests/traits.rs     |   2 +-
 7 files changed, 182 insertions(+), 209 deletions(-)
 create mode 100644 serde_dhall/src/error.rs
 create mode 100644 serde_dhall/src/simple.rs

(limited to 'serde_dhall/tests/traits.rs')

diff --git a/dhall_proc_macros/src/derive.rs b/dhall_proc_macros/src/derive.rs
index 3a4f1aa..4885b49 100644
--- a/dhall_proc_macros/src/derive.rs
+++ b/dhall_proc_macros/src/derive.rs
@@ -52,7 +52,7 @@ fn derive_for_struct(
         let ty = static_type(ty);
         quote!( (#name.to_owned(), #ty) )
     });
-    Ok(quote! { ::serde_dhall::Type::make_record_type(
+    Ok(quote! { ::serde_dhall::simple::Type::make_record_type(
         vec![ #(#entries),* ].into_iter()
     ) })
 }
@@ -89,7 +89,7 @@ fn derive_for_enum(
         })
         .collect::<Result<_, Error>>()?;
 
-    Ok(quote! { ::serde_dhall::Type::make_union_type(
+    Ok(quote! { ::serde_dhall::simple::Type::make_union_type(
         vec![ #(#entries),* ].into_iter()
     ) })
 }
@@ -165,7 +165,7 @@ pub fn derive_static_type_inner(
                 for #ident #ty_generics
                 #where_clause {
             fn static_type() ->
-                    ::serde_dhall::Type {
+                    ::serde_dhall::simple::Type {
                 #(#assertions)*
                 #get_type
             }
diff --git a/serde_dhall/src/error.rs b/serde_dhall/src/error.rs
new file mode 100644
index 0000000..91a0b94
--- /dev/null
+++ b/serde_dhall/src/error.rs
@@ -0,0 +1,30 @@
+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())
+    }
+}
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())
 }
diff --git a/serde_dhall/src/serde.rs b/serde_dhall/src/serde.rs
index e06fb3d..d144abf 100644
--- a/serde_dhall/src/serde.rs
+++ b/serde_dhall/src/serde.rs
@@ -7,9 +7,9 @@ use serde::de::value::{
 use dhall::syntax::NumKind;
 use dhall::{SValKind, SimpleValue};
 
-use crate::de::{Deserialize, Error, Result};
+use crate::{Deserialize, Error, Result};
 
-impl<'a, T> crate::de::sealed::Sealed for T where T: serde::Deserialize<'a> {}
+impl<'a, T> crate::sealed::Sealed for T where T: serde::Deserialize<'a> {}
 
 struct Deserializer<'a>(Cow<'a, SimpleValue>);
 
diff --git a/serde_dhall/src/simple.rs b/serde_dhall/src/simple.rs
new file mode 100644
index 0000000..93364a0
--- /dev/null
+++ b/serde_dhall/src/simple.rs
@@ -0,0 +1,81 @@
+use super::Error;
+use dhall::{STyKind, SimpleType, SimpleValue};
+
+/// A Dhall value. This is a wrapper around [`dhall::SimpleValue`].
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Value(SimpleValue);
+
+impl Value {
+    pub fn into_simple_value(self) -> SimpleValue {
+        self.0
+    }
+}
+
+/// 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::sealed::Sealed for Value {}
+
+impl super::Deserialize for Value {
+    fn from_dhall(v: &dhall::Value) -> super::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))
+    }
+}
+
+impl super::sealed::Sealed for Type {}
+
+impl super::Deserialize for Type {
+    fn from_dhall(v: &dhall::Value) -> super::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))
+    }
+}
diff --git a/serde_dhall/tests/de.rs b/serde_dhall/tests/de.rs
index 4042611..b201e4f 100644
--- a/serde_dhall/tests/de.rs
+++ b/serde_dhall/tests/de.rs
@@ -3,7 +3,7 @@ use serde_dhall::{from_str, from_str_auto_type, StaticType};
 
 #[test]
 fn test_de_typed() {
-    fn parse<T: serde_dhall::de::Deserialize + StaticType>(s: &str) -> T {
+    fn parse<T: serde_dhall::Deserialize + StaticType>(s: &str) -> T {
         from_str_auto_type(s).unwrap()
     }
 
@@ -57,7 +57,7 @@ fn test_de_typed() {
 
 #[test]
 fn test_de_untyped() {
-    fn parse<T: serde_dhall::de::Deserialize>(s: &str) -> T {
+    fn parse<T: serde_dhall::Deserialize>(s: &str) -> T {
         from_str(s).unwrap()
     }
 
diff --git a/serde_dhall/tests/traits.rs b/serde_dhall/tests/traits.rs
index b2fe6e5..f3c6f05 100644
--- a/serde_dhall/tests/traits.rs
+++ b/serde_dhall/tests/traits.rs
@@ -1,4 +1,4 @@
-use serde_dhall::{from_str, StaticType, Type};
+use serde_dhall::{from_str, simple::Type, StaticType};
 
 #[test]
 fn test_static_type() {
-- 
cgit v1.3.1


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

---
 dhall_proc_macros/src/derive.rs |  10 +--
 serde_dhall/src/lib.rs          |  12 ++--
 serde_dhall/src/options.rs      |   5 +-
 serde_dhall/src/shortcuts.rs    |  10 +--
 serde_dhall/src/simple.rs       | 145 +++++++++++++++++++++++++---------------
 serde_dhall/src/static_type.rs  |  26 +++----
 serde_dhall/src/value.rs        |   2 +-
 serde_dhall/tests/traits.rs     |   4 +-
 8 files changed, 125 insertions(+), 89 deletions(-)

(limited to 'serde_dhall/tests/traits.rs')

diff --git a/dhall_proc_macros/src/derive.rs b/dhall_proc_macros/src/derive.rs
index f7edf3a..e484ec6 100644
--- a/dhall_proc_macros/src/derive.rs
+++ b/dhall_proc_macros/src/derive.rs
@@ -53,9 +53,9 @@ fn derive_for_struct(
         quote!( (#name.to_owned(), #ty) )
     });
     Ok(quote! {
-        ::serde_dhall::simple::TyKind::Record(
+        ::serde_dhall::SimpleType::Record(
             vec![ #(#entries),* ].into_iter().collect()
-        ).into()
+        )
     })
 }
 
@@ -92,9 +92,9 @@ fn derive_for_enum(
         .collect::<Result<_, Error>>()?;
 
     Ok(quote! {
-        ::serde_dhall::simple::TyKind::Union(
+        ::serde_dhall::SimpleType::Union(
             vec![ #(#entries),* ].into_iter().collect()
-        ).into()
+        )
     })
 }
 
@@ -168,7 +168,7 @@ pub fn derive_static_type_inner(
         impl #impl_generics ::serde_dhall::StaticType
                 for #ident #ty_generics
                 #where_clause {
-            fn static_type() -> ::serde_dhall::simple::Type {
+            fn static_type() -> ::serde_dhall::SimpleType {
                 #(#assertions)*
                 #get_type
             }
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;
diff --git a/serde_dhall/src/options.rs b/serde_dhall/src/options.rs
index 19b8587..0072393 100644
--- a/serde_dhall/src/options.rs
+++ b/serde_dhall/src/options.rs
@@ -2,7 +2,7 @@ use std::path::{Path, PathBuf};
 
 use dhall::Parsed;
 
-use crate::simple::Type as SimpleType;
+use crate::SimpleType;
 use crate::{Deserialize, Error, Result, StaticType, Value};
 
 #[derive(Debug, Clone)]
@@ -94,7 +94,8 @@ impl<'a, T> Options<'a, T> {
     //     }
     //     self
     // }
-    // /// TODO
+    //
+    /// TODO
     pub fn type_annotation(&mut self, ty: &SimpleType) -> &mut Self {
         self.annot = Some(ty.clone());
         self
diff --git a/serde_dhall/src/shortcuts.rs b/serde_dhall/src/shortcuts.rs
index ddb738c..d88b9ac 100644
--- a/serde_dhall/src/shortcuts.rs
+++ b/serde_dhall/src/shortcuts.rs
@@ -1,8 +1,4 @@
-use crate::error::Result;
-use crate::options;
-use crate::simple::Type as SimpleType;
-use crate::static_type::StaticType;
-use crate::Deserialize;
+use crate::{options, Deserialize, Result, SimpleType, StaticType};
 
 /// Deserialize an instance of type `T` from a string of Dhall text.
 ///
@@ -56,12 +52,12 @@ where
 ///
 /// ```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 }";
diff --git a/serde_dhall/src/simple.rs b/serde_dhall/src/simple.rs
index 6f3dc93..fc640b6 100644
--- a/serde_dhall/src/simple.rs
+++ b/serde_dhall/src/simple.rs
@@ -1,4 +1,4 @@
-use std::collections::BTreeMap;
+use std::collections::{BTreeMap, HashMap};
 
 use dhall::semantics::{Hir, HirKind, Nir, NirKind};
 use dhall::syntax::{Builtin, ExprKind, NumKind, Span};
@@ -13,33 +13,82 @@ pub(crate) struct Value {
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub(crate) enum ValKind {
-    // TODO: redefine NumKind locally
     Num(NumKind),
     Text(String),
     Optional(Option<Value>),
     List(Vec<Value>),
-    // TODO: HashMap ?
     Record(BTreeMap<String, Value>),
     Union(String, Option<Value>),
 }
 
-/// The type of a value that can be decoded by Serde. For example, `{ x: Bool, y: List Natural }`.
+/// The type of a value that can be decoded by Serde, like `{ x: Bool, y: List Natural }`.
+///
+/// A `SimpleType` is used when deserializing values to ensure they are of the expected type.
+/// Rather than letting `serde` handle potential type mismatches, this uses the type-checking
+/// capabilities of Dhall to catch errors early and cleanly indicate in the user's code where the
+/// mismatch happened.
+///
+/// You would typically not manipulate `SimpleType`s by hand but rather let Rust infer it for your
+/// datatype using the [`StaticType`][TODO] trait, and methods that require it like
+/// [`from_file_static_type`][TODO] and [`Options::static_type_annotation`][TODO]. If you need to supply a
+/// `SimpleType` manually however, you can deserialize it like any other Dhall value using the
+/// functions provided by this crate.
+///
+/// # Examples
+///
+/// ```rust
+/// # fn main() -> serde_dhall::Result<()> {
+/// use std::collections::HashMap;
+/// use serde_dhall::SimpleType;
+///
+/// let ty: SimpleType =
+///     serde_dhall::from_str("{ x: Natural, y: Natural }")?;
+///
+/// let mut map = HashMap::new();
+/// map.insert("x".to_string(), SimpleType::Natural);
+/// map.insert("y".to_string(), SimpleType::Natural);
+/// assert_eq!(ty, SimpleType::Record(map));
+/// # Ok(())
+/// # }
+/// ```
+///
+/// ```rust
+/// # fn main() -> serde_dhall::Result<()> {
+/// use serde_dhall::{SimpleType, StaticType};
+///
+/// #[derive(StaticType)]
+/// struct Foo {
+///     x: bool,
+///     y: Vec<u64>,
+/// }
+///
+/// let ty: SimpleType =
+///     serde_dhall::from_str("{ x: Bool, y: List Natural }")?;
+///
+/// assert_eq!(ty, Foo::static_type());
+/// # Ok(())
+/// # }
+/// ```
 #[derive(Debug, Clone, PartialEq, Eq)]
-pub struct Type {
-    kind: Box<TyKind>,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub enum TyKind {
+pub enum SimpleType {
+    /// Corresponds to the Dhall type `Bool`
     Bool,
+    /// Corresponds to the Dhall type `Natural`
     Natural,
+    /// Corresponds to the Dhall type `Integer`
     Integer,
+    /// Corresponds to the Dhall type `Double`
     Double,
+    /// Corresponds to the Dhall type `Text`
     Text,
-    Optional(Type),
-    List(Type),
-    Record(BTreeMap<String, Type>),
-    Union(BTreeMap<String, Option<Type>>),
+    /// Corresponds to the Dhall type `Optional T`
+    Optional(Box<SimpleType>),
+    /// Corresponds to the Dhall type `List T`
+    List(Box<SimpleType>),
+    /// Corresponds to the Dhall type `{ x : T, y : U }`
+    Record(HashMap<String, SimpleType>),
+    /// Corresponds to the Dhall type `< x : T | y : U >`
+    Union(HashMap<String, Option<SimpleType>>),
 }
 
 impl Value {
@@ -87,30 +136,29 @@ impl Value {
     }
 }
 
-impl Type {
-    pub fn new(kind: TyKind) -> Self {
-        Type {
-            kind: Box::new(kind),
-        }
-    }
+impl SimpleType {
     pub(crate) fn from_nir(nir: &Nir) -> Option<Self> {
-        Some(Type::new(match nir.kind() {
+        Some(match nir.kind() {
             NirKind::BuiltinType(b) => match b {
-                Builtin::Bool => TyKind::Bool,
-                Builtin::Natural => TyKind::Natural,
-                Builtin::Integer => TyKind::Integer,
-                Builtin::Double => TyKind::Double,
-                Builtin::Text => TyKind::Text,
+                Builtin::Bool => SimpleType::Bool,
+                Builtin::Natural => SimpleType::Natural,
+                Builtin::Integer => SimpleType::Integer,
+                Builtin::Double => SimpleType::Double,
+                Builtin::Text => SimpleType::Text,
                 _ => unreachable!(),
             },
-            NirKind::OptionalType(t) => TyKind::Optional(Self::from_nir(t)?),
-            NirKind::ListType(t) => TyKind::List(Self::from_nir(t)?),
-            NirKind::RecordType(kts) => TyKind::Record(
+            NirKind::OptionalType(t) => {
+                SimpleType::Optional(Box::new(Self::from_nir(t)?))
+            }
+            NirKind::ListType(t) => {
+                SimpleType::List(Box::new(Self::from_nir(t)?))
+            }
+            NirKind::RecordType(kts) => SimpleType::Record(
                 kts.iter()
                     .map(|(k, v)| Some((k.into(), Self::from_nir(v)?)))
                     .collect::<Option<_>>()?,
             ),
-            NirKind::UnionType(kts) => TyKind::Union(
+            NirKind::UnionType(kts) => SimpleType::Union(
                 kts.iter()
                     .map(|(k, v)| {
                         Some((
@@ -123,13 +171,10 @@ impl Type {
                     .collect::<Option<_>>()?,
             ),
             _ => return None,
-        }))
+        })
     }
 
-    pub fn kind(&self) -> &TyKind {
-        self.kind.as_ref()
-    }
-    pub fn to_value(&self) -> crate::value::Value {
+    pub(crate) fn to_value(&self) -> crate::value::Value {
         crate::value::Value {
             hir: self.to_hir(),
             as_simple_val: None,
@@ -138,25 +183,25 @@ impl Type {
     }
     pub(crate) fn to_hir(&self) -> Hir {
         let hir = |k| Hir::new(HirKind::Expr(k), Span::Artificial);
-        hir(match self.kind() {
-            TyKind::Bool => ExprKind::Builtin(Builtin::Bool),
-            TyKind::Natural => ExprKind::Builtin(Builtin::Natural),
-            TyKind::Integer => ExprKind::Builtin(Builtin::Integer),
-            TyKind::Double => ExprKind::Builtin(Builtin::Double),
-            TyKind::Text => ExprKind::Builtin(Builtin::Text),
-            TyKind::Optional(t) => ExprKind::App(
+        hir(match self {
+            SimpleType::Bool => ExprKind::Builtin(Builtin::Bool),
+            SimpleType::Natural => ExprKind::Builtin(Builtin::Natural),
+            SimpleType::Integer => ExprKind::Builtin(Builtin::Integer),
+            SimpleType::Double => ExprKind::Builtin(Builtin::Double),
+            SimpleType::Text => ExprKind::Builtin(Builtin::Text),
+            SimpleType::Optional(t) => ExprKind::App(
                 hir(ExprKind::Builtin(Builtin::Optional)),
                 t.to_hir(),
             ),
-            TyKind::List(t) => {
+            SimpleType::List(t) => {
                 ExprKind::App(hir(ExprKind::Builtin(Builtin::List)), t.to_hir())
             }
-            TyKind::Record(kts) => ExprKind::RecordType(
+            SimpleType::Record(kts) => ExprKind::RecordType(
                 kts.into_iter()
                     .map(|(k, t)| (k.as_str().into(), t.to_hir()))
                     .collect(),
             ),
-            TyKind::Union(kts) => ExprKind::UnionType(
+            SimpleType::Union(kts) => ExprKind::UnionType(
                 kts.into_iter()
                     .map(|(k, t)| {
                         (k.as_str().into(), t.as_ref().map(|t| t.to_hir()))
@@ -180,9 +225,9 @@ impl Deserialize for Value {
     }
 }
 
-impl Sealed for Type {}
+impl Sealed for SimpleType {}
 
-impl Deserialize for Type {
+impl Deserialize for SimpleType {
     fn from_dhall(v: &crate::value::Value) -> Result<Self> {
         v.to_simple_type().ok_or_else(|| {
             Error::Deserialize(format!(
@@ -192,9 +237,3 @@ impl Deserialize for Type {
         })
     }
 }
-
-impl From<TyKind> for Type {
-    fn from(x: TyKind) -> Type {
-        Type::new(x)
-    }
-}
diff --git a/serde_dhall/src/static_type.rs b/serde_dhall/src/static_type.rs
index 3fdff39..ffbc3ad 100644
--- a/serde_dhall/src/static_type.rs
+++ b/serde_dhall/src/static_type.rs
@@ -1,4 +1,4 @@
-use crate::simple::{TyKind, Type};
+use crate::SimpleType;
 
 /// A Rust type that can be represented as a Dhall type.
 ///
@@ -13,14 +13,14 @@ use crate::simple::{TyKind, Type};
 /// have a different Dhall record type.
 /// TODO
 pub trait StaticType {
-    fn static_type() -> Type;
+    fn static_type() -> SimpleType;
 }
 
 macro_rules! derive_builtin {
     ($rust_ty:ty, $dhall_ty:ident) => {
         impl StaticType for $rust_ty {
-            fn static_type() -> Type {
-                Type::new(TyKind::$dhall_ty)
+            fn static_type() -> SimpleType {
+                SimpleType::$dhall_ty
             }
         }
     };
@@ -42,8 +42,8 @@ where
     A: StaticType,
     B: StaticType,
 {
-    fn static_type() -> Type {
-        TyKind::Record(
+    fn static_type() -> SimpleType {
+        SimpleType::Record(
             vec![
                 ("_1".to_owned(), A::static_type()),
                 ("_2".to_owned(), B::static_type()),
@@ -60,8 +60,8 @@ where
     T: StaticType,
     E: StaticType,
 {
-    fn static_type() -> Type {
-        TyKind::Union(
+    fn static_type() -> SimpleType {
+        SimpleType::Union(
             vec![
                 ("Ok".to_owned(), Some(T::static_type())),
                 ("Err".to_owned(), Some(E::static_type())),
@@ -77,8 +77,8 @@ impl<T> StaticType for Option<T>
 where
     T: StaticType,
 {
-    fn static_type() -> Type {
-        TyKind::Optional(T::static_type()).into()
+    fn static_type() -> SimpleType {
+        SimpleType::Optional(Box::new(T::static_type())).into()
     }
 }
 
@@ -86,8 +86,8 @@ impl<T> StaticType for Vec<T>
 where
     T: StaticType,
 {
-    fn static_type() -> Type {
-        TyKind::List(T::static_type()).into()
+    fn static_type() -> SimpleType {
+        SimpleType::List(Box::new(T::static_type())).into()
     }
 }
 
@@ -95,7 +95,7 @@ impl<'a, T> StaticType for &'a T
 where
     T: StaticType,
 {
-    fn static_type() -> Type {
+    fn static_type() -> SimpleType {
         T::static_type()
     }
 }
diff --git a/serde_dhall/src/value.rs b/serde_dhall/src/value.rs
index 41a96ea..e8aae49 100644
--- a/serde_dhall/src/value.rs
+++ b/serde_dhall/src/value.rs
@@ -1,7 +1,7 @@
 use dhall::semantics::{Hir, Nir};
 use dhall::syntax::Expr;
 
-use crate::simple::{Type as SimpleType, Value as SimpleValue};
+use crate::simple::{SimpleType, Value as SimpleValue};
 use crate::{Deserialize, Error, Sealed};
 
 /// An arbitrary Dhall value.
diff --git a/serde_dhall/tests/traits.rs b/serde_dhall/tests/traits.rs
index f3c6f05..608e6ed 100644
--- a/serde_dhall/tests/traits.rs
+++ b/serde_dhall/tests/traits.rs
@@ -1,8 +1,8 @@
-use serde_dhall::{from_str, simple::Type, StaticType};
+use serde_dhall::{from_str, SimpleType, StaticType};
 
 #[test]
 fn test_static_type() {
-    fn parse(s: &str) -> Type {
+    fn parse(s: &str) -> SimpleType {
         from_str(s).unwrap()
     }
 
-- 
cgit v1.3.1


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

---
 README.md                      |   2 +-
 serde_dhall/src/deserialize.rs |   2 +-
 serde_dhall/src/lib.rs         |  25 ++--
 serde_dhall/src/options.rs     |  29 +++--
 serde_dhall/src/shortcuts.rs   | 272 -----------------------------------------
 serde_dhall/src/static_type.rs |   4 +-
 serde_dhall/src/value.rs       |   6 +-
 serde_dhall/tests/de.rs        |  10 +-
 serde_dhall/tests/traits.rs    |   2 +-
 9 files changed, 37 insertions(+), 315 deletions(-)
 delete mode 100644 serde_dhall/src/shortcuts.rs

(limited to 'serde_dhall/tests/traits.rs')

diff --git a/README.md b/README.md
index efe4c91..ceb33cd 100644
--- a/README.md
+++ b/README.md
@@ -58,7 +58,7 @@ use std::collections::BTreeMap;
 let data = "{ x = 1, y = 1 + 1 } : { x: Natural, y: Natural }";
 
 // Deserialize it to a Rust type.
-let deserialized_map: BTreeMap<String, usize> = serde_dhall::from_str(data).unwrap();
+let deserialized_map: BTreeMap<String, usize> = serde_dhall::from_str(data).parse().unwrap();
 
 let mut expected_map = BTreeMap::new();
 expected_map.insert("x".to_string(), 1);
diff --git a/serde_dhall/src/deserialize.rs b/serde_dhall/src/deserialize.rs
index 1be68c4..92be2e9 100644
--- a/serde_dhall/src/deserialize.rs
+++ b/serde_dhall/src/deserialize.rs
@@ -30,7 +30,7 @@ pub trait Sealed {}
 /// }
 ///
 /// // Convert a Dhall string to a Point.
-/// let point: Point = serde_dhall::from_str("{ x = 1, y = 1 + 1 }")?;
+/// let point: Point = serde_dhall::from_str("{ x = 1, y = 1 + 1 }").parse()?;
 /// # Ok(())
 /// # }
 /// ```
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};
diff --git a/serde_dhall/src/options.rs b/serde_dhall/src/options.rs
index f3797ee..c44de90 100644
--- a/serde_dhall/src/options.rs
+++ b/serde_dhall/src/options.rs
@@ -27,9 +27,9 @@ enum Source<'a> {
 ///
 /// ```no_run
 /// # fn main() -> serde_dhall::Result<()> {
-/// use serde_dhall::options;
+/// use serde_dhall::from_file;
 ///
-/// let data = options::from_file("foo.dhall").parse()?;
+/// let data = from_file("foo.dhall").parse()?;
 /// # Ok(())
 /// # }
 /// ```
@@ -38,10 +38,10 @@ enum Source<'a> {
 ///
 /// ```no_run
 /// # fn main() -> serde_dhall::Result<()> {
-/// use serde_dhall::options;
+/// use serde_dhall::{from_file, from_str};
 ///
-/// let ty = options::from_str("{ x: Natural, y: Natural }").parse()?;
-/// let data = options::from_file("foo.dhall")
+/// let ty = from_str("{ x: Natural, y: Natural }").parse()?;
+/// let data = from_file("foo.dhall")
 ///             .type_annotation(&ty)
 ///             .parse()?;
 /// # Ok(())
@@ -91,7 +91,7 @@ impl<'a, T> Deserializer<'a, T> {
     ///
     /// let data = "12 + ./other_file.dhall : Natural";
     /// assert!(
-    ///     serde_dhall::options::from_str::<u64>(data)
+    ///     serde_dhall::from_str::<u64>(data)
     ///         .imports(false)
     ///         .parse()
     ///         .is_err()
@@ -136,11 +136,11 @@ impl<'a, T> Deserializer<'a, T> {
     ///
     /// // Parse a Dhall type
     /// let point_type_str = "{ x: Natural, y: Optional Natural }";
-    /// let point_type: SimpleType = serde_dhall::options::from_str(point_type_str).parse()?;
+    /// let point_type: SimpleType = serde_dhall::from_str(point_type_str).parse()?;
     ///
     /// // Parse some Dhall data to a Point.
     /// let data = "{ x = 1, y = Some (1 + 1) }";
-    /// let point: Point = serde_dhall::options::from_str(data)
+    /// let point: Point = serde_dhall::from_str(data)
     ///     .type_annotation(&point_type)
     ///     .parse()?;
     /// assert_eq!(point.x, 1);
@@ -149,7 +149,7 @@ impl<'a, T> Deserializer<'a, T> {
     /// // Invalid data fails the type validation; deserialization would have succeeded otherwise.
     /// let invalid_data = "{ x = 1 }";
     /// assert!(
-    ///     serde_dhall::options::from_str::<Point>(invalid_data)
+    ///     serde_dhall::from_str::<Point>(invalid_data)
     ///         .type_annotation(&point_type)
     ///         .parse()
     ///         .is_err()
@@ -187,7 +187,7 @@ impl<'a, T> Deserializer<'a, T> {
     /// let data = "{ x = 1, y = Some (1 + 1) }";
     ///
     /// // Convert the Dhall string to a Point.
-    /// let point: Point = serde_dhall::options::from_str(data)
+    /// let point: Point = serde_dhall::from_str(data)
     ///     .static_type_annotation()
     ///     .parse()?;
     /// assert_eq!(point.x, 1);
@@ -196,7 +196,7 @@ impl<'a, T> Deserializer<'a, T> {
     /// // Invalid data fails the type validation; deserialization would have succeeded otherwise.
     /// let invalid_data = "{ x = 1 }";
     /// assert!(
-    ///     serde_dhall::options::from_str::<Point>(invalid_data)
+    ///     serde_dhall::from_str::<Point>(invalid_data)
     ///         .static_type_annotation()
     ///         .parse()
     ///         .is_err()
@@ -240,8 +240,7 @@ impl<'a, T> Deserializer<'a, T> {
     ///
     /// ```no_run
     /// # fn main() -> serde_dhall::Result<()> {
-    /// use serde_dhall::options;
-    /// let data = options::from_file("foo.dhall").parse()?;
+    /// let data = serde_dhall::from_file("foo.dhall").parse()?;
     /// # Ok(())
     /// # }
     /// ```
@@ -276,7 +275,7 @@ impl<'a, T> Deserializer<'a, T> {
 /// let data = "{ x = 1, y = 1 + 1 } : { x: Natural, y: Natural }";
 ///
 /// // Parse the Dhall string as a Point.
-/// let point: Point = serde_dhall::options::from_str(data).parse()?;
+/// let point: Point = serde_dhall::from_str(data).parse()?;
 ///
 /// assert_eq!(point.x, 1);
 /// assert_eq!(point.y, 2);
@@ -309,7 +308,7 @@ pub fn from_str<T>(s: &str) -> Deserializer<'_, T> {
 /// }
 ///
 /// // Parse the Dhall file as a Point.
-/// let point: Point = serde_dhall::options::from_file("foo.dhall").parse()?;
+/// let point: Point = serde_dhall::from_file("foo.dhall").parse()?;
 /// # Ok(())
 /// # }
 /// ```
diff --git a/serde_dhall/src/shortcuts.rs b/serde_dhall/src/shortcuts.rs
deleted file mode 100644
index 9c9ce9f..0000000
--- a/serde_dhall/src/shortcuts.rs
+++ /dev/null
@@ -1,272 +0,0 @@
-use doc_comment::doc_comment;
-use std::path::Path;
-
-use crate::{options, FromDhall, Result, SimpleType, StaticType};
-
-// Avoid copy-pasting documentation
-
-#[rustfmt::skip]
-macro_rules! gen_doc {
-    (@source_desc, str) => {"a string of Dhall text"};
-    (@source_desc, file) => {"a Dhall file"};
-    (@source_desc, url) => {"a remote url"};
-
-    (@tck_info1, none) => {""};
-    (@tck_info1, manual) => {", additionally checking that it matches the supplied type"};
-    (@tck_info1, static) => {", additionally checking that it matches the type of `T`"};
-
-    (@tck_info2, none) => {""};
-    (@tck_info2, manual) => {" against the supplied type"};
-    (@tck_info2, static) => {" against the type of `T`"};
-
-    (@tck_req, $src:tt, none) => {""};
-    (@tck_req, $src:tt, manual) => {""};
-    (@tck_req, $src:tt, static) => {
-        concat!("`T` must implement the [`StaticType`] trait. Use [`from_", stringify!($src),
-                "_manual_type`] to provide a type manually.\n")
-    };
-
-    (@tck_comment, $src:tt, none) => {
-        concat!("For additional type safety, prefer [`from_", stringify!($src), "_static_type`]
-                 or [`from_", stringify!($src), "_manual_type`].\n")
-    };
-    (@tck_comment, $src:tt, manual) => {concat!("See also [`from_", stringify!($src), "_static_type`].\n")};
-    (@tck_comment, $src:tt, static) => {""};
-
-    (@run_example, str) => {""};
-    (@run_example, file) => {"no_run"};
-    (@run_example, url) => {"no_run"};
-
-    ($src:tt, $ty:tt) => {concat!("
-Deserialize an instance of type `T` from ", gen_doc!(@source_desc, $src), gen_doc!(@tck_info1, $ty),".
-
-", gen_doc!(@tck_req, $src, $ty), "
-This will recursively resolve all imports in the expression, and typecheck it", gen_doc!(@tck_info2, $ty),"
-before deserialization. Relative imports will be resolved relative to the current directory.
-See [`options`] for more control over this process.
-
-", gen_doc!(@tck_comment, $src, $ty), "
-
-# Example
-
-```", gen_doc!(@run_example, $src), "
-# fn main() -> serde_dhall::Result<()> {",
-gen_example!($src, $ty), "
-# Ok(())
-# }
-```
-
-[`options`]: options/index.html
-[`from_", stringify!($src), "_manual_type`]: fn.from_", stringify!($src), "_manual_type.html
-[`from_", stringify!($src), "_static_type`]: fn.from_", stringify!($src), "_static_type.html
-[`StaticType`]: trait.StaticType.html
-")};
-}
-
-#[rustfmt::skip]
-macro_rules! gen_example {
-    (str, none) => {concat!(r#"
-use serde::Deserialize;
-
-// We use serde's derive feature
-#[derive(Deserialize)]
-struct Point {
-    x: u64,
-    y: u64,
-}
-
-// Some Dhall data
-let data = "{ x = 1, y = 1 + 1 } : { x: Natural, y: Natural }";
-
-// Parse the Dhall string as a Point.
-let point: Point = serde_dhall::from_str(data)?;
-
-assert_eq!(point.x, 1);
-assert_eq!(point.y, 2);
-"#)};
-
-    (str, manual) => {concat!(r#"
-use std::collections::HashMap;
-use serde_dhall::SimpleType;
-
-// Parse a Dhall type
-let point_type_str = "{ x: Natural, y: Natural }";
-let point_type: SimpleType = serde_dhall::from_str(point_type_str)?;
-
-// 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_manual_type(point_data, &point_type)?;
-
-let mut expected_map = HashMap::new();
-expected_map.insert("x".to_string(), 1);
-expected_map.insert("y".to_string(), 2);
-
-assert_eq!(deserialized_map, expected_map);
-"#)};
-
-    (str, static) => {concat!(r#"
-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());
-"#)};
-
-    (file, none) => {concat!(r#"
-use serde::Deserialize;
-
-// We use serde's derive feature
-#[derive(Deserialize)]
-struct Point {
-    x: u64,
-    y: u64,
-}
-
-// Parse the Dhall file as a Point.
-let point: Point = serde_dhall::from_file("foo.dhall")?;
-"#)};
-
-    (file, manual) => {concat!(r#"
-use std::collections::HashMap;
-use serde_dhall::SimpleType;
-
-// Parse a Dhall type
-let point_type_str = "{ x: Natural, y: Natural }";
-let point_type: SimpleType = serde_dhall::from_str(point_type_str)?;
-
-// 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_file_manual_type("foo.dhall", &point_type)?;
-"#)};
-
-    (file, static) => {concat!(r#"
-use serde::Deserialize;
-use serde_dhall::StaticType;
-
-#[derive(Deserialize, StaticType)]
-struct Point {
-    x: u64,
-    y: u64,
-}
-
-// Convert the Dhall string to a Point.
-let point: Point = serde_dhall::from_file_static_type("foo.dhall")?;
-"#)};
-
-    ($src:tt, $ty:tt) => {""};
-}
-
-macro_rules! generate_fn {
-    (@generate_src,
-        str, $ty:tt, $name:ident,
-    ) => {
-        generate_fn!(@generate_ty,
-            str, $ty, $name,
-            (),
-            (s: &str),
-            (options::from_str(s)),
-        );
-    };
-    (@generate_src,
-        file, $ty:tt, $name:ident,
-    ) => {
-        generate_fn!(@generate_ty,
-            file, $ty, $name,
-            (P: AsRef<Path>),
-            (path: P),
-            (options::from_file(path)),
-        );
-    };
-
-    (@generate_ty,
-        $src:tt, none, $name:ident,
-        ($($ty_params:tt)*),
-        ($($input_args:tt)*),
-        ($($create_options:tt)*),
-    ) => {
-        generate_fn!(@generate,
-            $src, none, $name,
-            ($($ty_params)*),
-            ($($input_args)*),
-            (),
-            ($($create_options)*),
-        );
-    };
-    (@generate_ty,
-        $src:tt, manual, $name:ident,
-        ($($ty_params:tt)*),
-        ($($input_args:tt)*),
-        ($($create_options:tt)*),
-    ) => {
-        generate_fn!(@generate,
-            $src, manual, $name,
-            ($($ty_params)*),
-            ($($input_args)*, ty: &SimpleType),
-            (),
-            ($($create_options)* .type_annotation(ty)),
-        );
-    };
-    (@generate_ty,
-        $src:tt, static, $name:ident,
-        ($($ty_params:tt)*),
-        ($($input_args:tt)*),
-        ($($create_options:tt)*),
-    ) => {
-        generate_fn!(@generate,
-            $src, static, $name,
-            ($($ty_params)*),
-            ($($input_args)*),
-            (+ StaticType),
-            ($($create_options)* .static_type_annotation()),
-        );
-    };
-
-    (@generate,
-        $src:tt, $ty:tt, $name:ident,
-        ($($ty_params:tt)*),
-        ($($input_args:tt)*),
-        ($($extra_bounds:tt)*),
-        ($($create_options:tt)*),
-    ) => {
-        doc_comment! {
-            gen_doc!($src, $ty),
-            pub fn $name<T, $($ty_params)*> ($($input_args)*) -> Result<T>
-            where
-                T: FromDhall $($extra_bounds)*,
-            {
-                $($create_options)* .parse()
-            }
-        }
-    };
-
-    ($src:tt, $ty:tt, $name:ident) => {
-        generate_fn!(@generate_src, $src, $ty, $name,);
-    };
-}
-
-generate_fn!(str, none, from_str);
-generate_fn!(str, manual, from_str_manual_type);
-generate_fn!(str, static, from_str_static_type);
-generate_fn!(file, none, from_file);
-generate_fn!(file, manual, from_file_manual_type);
-generate_fn!(file, static, from_file_static_type);
diff --git a/serde_dhall/src/static_type.rs b/serde_dhall/src/static_type.rs
index 020dfce..6e76424 100644
--- a/serde_dhall/src/static_type.rs
+++ b/serde_dhall/src/static_type.rs
@@ -23,7 +23,7 @@ use crate::SimpleType;
 /// }
 ///
 /// let ty: SimpleType =
-///     serde_dhall::from_str("{ x: Bool, y: List Natural }")?;
+///     serde_dhall::from_str("{ x: Bool, y: List Natural }").parse()?;
 ///
 /// assert_eq!(Foo::static_type(), ty);
 /// # Ok(())
@@ -71,7 +71,7 @@ pub trait StaticType {
     ///     }
     /// }
     ///
-    /// let foo: Foo = serde_dhall::from_str_static_type("[ 1, 2 ]")?;
+    /// let foo: Foo = serde_dhall::from_str("[ 1, 2 ]").static_type_annotation().parse()?;
     ///
     /// assert_eq!(foo.0, vec![1, 2]);
     /// # Ok(())
diff --git a/serde_dhall/src/value.rs b/serde_dhall/src/value.rs
index ea7c20a..f21e836 100644
--- a/serde_dhall/src/value.rs
+++ b/serde_dhall/src/value.rs
@@ -28,7 +28,7 @@ pub(crate) enum SimpleValue {
     Union(String, Option<Box<SimpleValue>>),
 }
 
-/// The type of a value that can be decoded by Serde, like `{ x: Bool, y: List Natural }`.
+/// The type of a value that can be decoded by Serde, e.g. `{ x: Bool, y: List Natural }`.
 ///
 /// A `SimpleType` is used when deserializing values to ensure they are of the expected type.
 /// Rather than letting `serde` handle potential type mismatches, this uses the type-checking
@@ -53,7 +53,7 @@ pub(crate) enum SimpleValue {
 /// use serde_dhall::SimpleType;
 ///
 /// let ty: SimpleType =
-///     serde_dhall::from_str("{ x: Natural, y: Natural }")?;
+///     serde_dhall::from_str("{ x: Natural, y: Natural }").parse()?;
 ///
 /// let mut map = HashMap::new();
 /// map.insert("x".to_string(), SimpleType::Natural);
@@ -74,7 +74,7 @@ pub(crate) enum SimpleValue {
 /// }
 ///
 /// let ty: SimpleType =
-///     serde_dhall::from_str("{ x: Bool, y: List Natural }")?;
+///     serde_dhall::from_str("{ x: Bool, y: List Natural }").parse()?;
 ///
 /// assert_eq!(Foo::static_type(), ty);
 /// # Ok(())
diff --git a/serde_dhall/tests/de.rs b/serde_dhall/tests/de.rs
index b9a504a..970234b 100644
--- a/serde_dhall/tests/de.rs
+++ b/serde_dhall/tests/de.rs
@@ -1,10 +1,10 @@
 use serde::Deserialize;
-use serde_dhall::{from_str, from_str_static_type, FromDhall, StaticType};
+use serde_dhall::{from_str, FromDhall, StaticType};
 
 #[test]
 fn test_de_typed() {
     fn parse<T: FromDhall + StaticType>(s: &str) -> T {
-        from_str_static_type(s).unwrap()
+        from_str(s).static_type_annotation().parse().unwrap()
     }
 
     assert_eq!(parse::<bool>("True"), true);
@@ -52,13 +52,13 @@ fn test_de_typed() {
     }
     assert_eq!(parse::<Baz>("< X | Y: Integer >.X"), Baz::X);
 
-    assert!(from_str_static_type::<Baz>("< X | Y: Integer >.Y").is_err());
+    assert!(from_str::<Baz>("< X | Y: Integer >.Y").static_type_annotation().parse().is_err());
 }
 
 #[test]
 fn test_de_untyped() {
     fn parse<T: FromDhall>(s: &str) -> T {
-        from_str(s).unwrap()
+        from_str(s).parse().unwrap()
     }
 
     // Test tuples on record of wrong type
@@ -94,5 +94,5 @@ fn test_de_untyped() {
     assert_eq!(parse::<Foo>("{ x = 1 }"), Foo { x: 1, y: None });
 
     // https://github.com/Nadrieril/dhall-rust/issues/155
-    assert!(from_str::<bool>("List/length [True, 42]").is_err());
+    assert!(from_str::<bool>("List/length [True, 42]").parse().is_err());
 }
diff --git a/serde_dhall/tests/traits.rs b/serde_dhall/tests/traits.rs
index 608e6ed..3c6fbfe 100644
--- a/serde_dhall/tests/traits.rs
+++ b/serde_dhall/tests/traits.rs
@@ -3,7 +3,7 @@ use serde_dhall::{from_str, SimpleType, StaticType};
 #[test]
 fn test_static_type() {
     fn parse(s: &str) -> SimpleType {
-        from_str(s).unwrap()
+        from_str(s).parse().unwrap()
     }
 
     assert_eq!(bool::static_type(), parse("Bool"));
-- 
cgit v1.3.1