5 files changed, 27 insertions, 18 deletions

diff --git a/serde_dhall/src/deserialize.rs b/serde_dhall/src/deserialize.rs
index ab5580e..7bb0051 100644
--- a/serde_dhall/src/deserialize.rs
+++ b/serde_dhall/src/deserialize.rs
@@ -6,7 +6,7 @@ use std::borrow::Cow;
 use dhall::syntax::NumKind;
 
 use crate::value::SimpleValue;
-use crate::{Error, Result, Value};
+use crate::{Error, ErrorKind, Result, Value};
 
 pub trait Sealed {}
 
@@ -33,10 +33,10 @@ where
 {
     fn from_dhall(v: &Value) -> Result<Self> {
         let sval = v.to_simple_value().ok_or_else(|| {
-            Error::Deserialize(format!(
+            Error(ErrorKind::Deserialize(format!(
                 "this cannot be deserialized into the serde data model: {}",
                 v
-            ))
+            )))
         })?;
         T::deserialize(Deserializer(Cow::Owned(sval)))
     }
diff --git a/serde_dhall/src/error.rs b/serde_dhall/src/error.rs
index 23d1b02..896e8b9 100644
--- a/serde_dhall/src/error.rs
+++ b/serde_dhall/src/error.rs
@@ -1,21 +1,29 @@
 use dhall::error::Error as DhallError;
 
-/// TODO
+/// Alias for a `Result` with the error type `serde_dhall::Error`.
 pub type Result<T> = std::result::Result<T, Error>;
 
+/// Errors that can occur when deserializing Dhall data.
 #[derive(Debug)]
-#[non_exhaustive]
-/// TODO
-pub enum Error {
+pub struct Error(pub(crate) ErrorKind);
+
+#[derive(Debug)]
+pub(crate) enum ErrorKind {
     Dhall(DhallError),
     Deserialize(String),
 }
 
+impl From<ErrorKind> for Error {
+    fn from(kind: ErrorKind) -> Error {
+        Error(kind)
+    }
+}
+
 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),
+        match &self.0 {
+            ErrorKind::Dhall(err) => write!(f, "{}", err),
+            ErrorKind::Deserialize(err) => write!(f, "{}", err),
         }
     }
 }
@@ -27,6 +35,6 @@ impl serde::de::Error for Error {
     where
         T: std::fmt::Display,
     {
-        Error::Deserialize(msg.to_string())
+        ErrorKind::Deserialize(msg.to_string()).into()
     }
 }
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,
diff --git a/serde_dhall/src/options.rs b/serde_dhall/src/options.rs
index f468cf0..f260572 100644
--- a/serde_dhall/src/options.rs
+++ b/serde_dhall/src/options.rs
@@ -3,7 +3,7 @@ use std::path::{Path, PathBuf};
 use dhall::Parsed;
 
 use crate::SimpleType;
-use crate::{Deserialize, Error, Result, StaticType, Value};
+use crate::{Deserialize, Error, ErrorKind, Result, StaticType, Value};
 
 #[derive(Debug, Clone)]
 enum Source<'a> {
@@ -130,7 +130,7 @@ impl<'a, T> Options<'a, T> {
     where
         T: Deserialize,
     {
-        let val = self._parse().map_err(Error::Dhall)?;
+        let val = self._parse().map_err(ErrorKind::Dhall).map_err(Error)?;
         T::from_dhall(&val)
     }
 }
diff --git a/serde_dhall/src/value.rs b/serde_dhall/src/value.rs
index bdc914f..3543f4d 100644
--- a/serde_dhall/src/value.rs
+++ b/serde_dhall/src/value.rs
@@ -3,7 +3,7 @@ use std::collections::{BTreeMap, HashMap};
 use dhall::semantics::{Hir, HirKind, Nir, NirKind};
 use dhall::syntax::{Builtin, Expr, ExprKind, NumKind, Span};
 
-use crate::{Deserialize, Error, Result, Sealed};
+use crate::{Deserialize, Error, ErrorKind, Result, Sealed};
 
 #[doc(hidden)]
 /// An arbitrary Dhall value.
@@ -254,20 +254,20 @@ impl Deserialize for Value {
 impl Deserialize for SimpleValue {
     fn from_dhall(v: &Value) -> Result<Self> {
         v.to_simple_value().ok_or_else(|| {
-            Error::Deserialize(format!(
+            Error(ErrorKind::Deserialize(format!(
                 "this cannot be deserialized into a simple type: {}",
                 v
-            ))
+            )))
         })
     }
 }
 impl Deserialize for SimpleType {
     fn from_dhall(v: &Value) -> Result<Self> {
         v.to_simple_type().ok_or_else(|| {
-            Error::Deserialize(format!(
+            Error(ErrorKind::Deserialize(format!(
                 "this cannot be deserialized into a simple type: {}",
                 v
-            ))
+            )))
         })
     }
 }