summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--dhall/src/api/mod.rs80
-rw-r--r--dhall/src/api/serde.rs15
-rw-r--r--dhall/src/api/traits/deserialize.rs53
-rw-r--r--dhall/src/api/traits/mod.rs2
-rw-r--r--dhall/src/lib.rs1
-rw-r--r--dhall/src/phase/mod.rs8
-rw-r--r--dhall/src/tests.rs2
7 files changed, 73 insertions, 88 deletions
diff --git a/dhall/src/api/mod.rs b/dhall/src/api/mod.rs
index 72789d9..233d7cf 100644
--- a/dhall/src/api/mod.rs
+++ b/dhall/src/api/mod.rs
@@ -1,16 +1,43 @@
mod serde;
pub(crate) mod static_type;
-pub(crate) mod traits;
-// pub struct Value(crate::phase::Normalized);
+pub use value::Value;
+
+mod value {
+ use super::Type;
+ use crate::error::Result;
+ use crate::phase::{NormalizedSubExpr, Parsed, Typed};
+
+ // A Dhall value
+ pub struct Value(Typed);
+
+ impl Value {
+ pub fn from_str(s: &str, ty: Option<&Type>) -> Result<Self> {
+ let resolved = Parsed::parse_str(s)?.resolve()?;
+ let typed = match ty {
+ None => resolved.typecheck()?,
+ Some(t) => resolved.typecheck_with(&t.to_type())?,
+ };
+ Ok(Value(typed))
+ }
+ pub(crate) fn to_expr(&self) -> NormalizedSubExpr {
+ self.0.to_expr()
+ }
+ pub(crate) fn to_typed(&self) -> Typed {
+ self.0.clone()
+ }
+ }
+}
pub use typ::Type;
mod typ {
+ use dhall_syntax::Builtin;
+
use crate::core::thunk::{Thunk, TypeThunk};
use crate::core::value::Value;
+ use crate::error::Result;
use crate::phase::{NormalizedSubExpr, Typed};
- use dhall_syntax::Builtin;
/// A Dhall expression representing a type.
///
@@ -72,18 +99,38 @@ mod typ {
pub(crate) fn to_expr(&self) -> NormalizedSubExpr {
self.0.to_expr()
}
+ pub(crate) fn to_type(&self) -> crate::phase::Type {
+ self.0.to_type()
+ }
+ }
+
+ impl crate::de::Deserialize for Type {
+ fn from_dhall(v: &crate::api::Value) -> Result<Self> {
+ Ok(Type(v.to_typed()))
+ }
}
}
/// Deserialization of Dhall expressions into Rust
pub mod de {
pub use super::static_type::StaticType;
- pub use super::Type;
- #[doc(hidden)]
- pub use crate::traits::Deserialize;
+ pub use super::{Type, Value};
+ use crate::error::Result;
#[doc(hidden)]
pub use dhall_proc_macros::StaticType;
+ /// 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.
+ // TODO: seal trait
+ pub trait Deserialize: Sized {
+ /// See [dhall::de::from_str][crate::de::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
@@ -93,11 +140,11 @@ pub mod de {
///
/// If a type is provided, this additionally checks that the provided
/// expression has that type.
- pub fn from_str<'a, T: Deserialize<'a>>(
- s: &'a str,
- ty: Option<&crate::phase::Type>,
- ) -> crate::error::Result<T> {
- T::from_str(s, ty)
+ pub fn from_str<T>(s: &str, ty: Option<&Type>) -> Result<T>
+ where
+ T: Deserialize,
+ {
+ T::from_dhall(&Value::from_str(s, ty)?)
}
/// Deserialize an instance of type T from a string of Dhall text,
@@ -107,11 +154,10 @@ pub mod de {
/// 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_auto_type<'a, T: Deserialize<'a> + StaticType>(
- s: &'a str,
- ) -> crate::error::Result<T> {
- // from_str(s, Some(&<T as StaticType>::static_type()))
- // TODO
- from_str(s, None)
+ pub fn from_str_auto_type<T>(s: &str) -> Result<T>
+ where
+ T: Deserialize + StaticType,
+ {
+ from_str(s, Some(&<T as StaticType>::static_type()))
}
}
diff --git a/dhall/src/api/serde.rs b/dhall/src/api/serde.rs
index 93921ba..7be77c0 100644
--- a/dhall/src/api/serde.rs
+++ b/dhall/src/api/serde.rs
@@ -1,13 +1,14 @@
+use crate::api::de::{Deserialize, Value};
use crate::error::{Error, Result};
-use crate::phase::{Normalized, Type};
-use crate::traits::Deserialize;
-use dhall_syntax::*;
+use dhall_syntax::{SubExpr,ExprF, X};
use std::borrow::Cow;
-impl<'a, T: serde::Deserialize<'a>> Deserialize<'a> for T {
- fn from_str(s: &'a str, ty: Option<&Type>) -> Result<Self> {
- let expr = Normalized::from_str(s, ty)?;
- T::deserialize(Deserializer(Cow::Owned(expr.to_expr())))
+impl<'a, T> Deserialize for T
+where
+ T: serde::Deserialize<'a>,
+{
+ fn from_dhall(v: &Value) -> Result<Self> {
+ T::deserialize(Deserializer(Cow::Owned(v.to_expr())))
}
}
diff --git a/dhall/src/api/traits/deserialize.rs b/dhall/src/api/traits/deserialize.rs
deleted file mode 100644
index 9673cf9..0000000
--- a/dhall/src/api/traits/deserialize.rs
+++ /dev/null
@@ -1,53 +0,0 @@
-use crate::error::*;
-use crate::phase::*;
-
-/// 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<'de>: Sized {
- /// See [dhall::de::from_str][crate::de::from_str]
- fn from_str(s: &'de str, ty: Option<&Type>) -> Result<Self>;
-}
-
-impl<'de> Deserialize<'de> for Parsed {
- /// Simply parses the provided string. Ignores the
- /// provided type.
- fn from_str(s: &'de str, _: Option<&Type>) -> Result<Self> {
- Ok(Parsed::parse_str(s)?)
- }
-}
-
-impl<'de> Deserialize<'de> for Resolved {
- /// Parses and resolves the provided string. Ignores the
- /// provided type.
- fn from_str(s: &'de str, ty: Option<&Type>) -> Result<Self> {
- Ok(Parsed::from_str(s, ty)?.resolve()?)
- }
-}
-
-impl<'de> Deserialize<'de> for Typed {
- /// Parses, resolves and typechecks the provided string.
- fn from_str(s: &'de str, ty: Option<&Type>) -> Result<Self> {
- let resolved = Resolved::from_str(s, ty)?;
- match ty {
- None => Ok(resolved.typecheck()?),
- Some(t) => Ok(resolved.typecheck_with(t)?),
- }
- }
-}
-
-impl<'de> Deserialize<'de> for Normalized {
- /// Parses, resolves, typechecks and normalizes the provided string.
- fn from_str(s: &'de str, ty: Option<&Type>) -> Result<Self> {
- Ok(Typed::from_str(s, ty)?.normalize())
- }
-}
-
-impl<'de> Deserialize<'de> for Type {
- fn from_str(s: &'de str, ty: Option<&Type>) -> Result<Self> {
- Ok(Normalized::from_str(s, ty)?.to_type())
- }
-}
diff --git a/dhall/src/api/traits/mod.rs b/dhall/src/api/traits/mod.rs
deleted file mode 100644
index 3fd21e4..0000000
--- a/dhall/src/api/traits/mod.rs
+++ /dev/null
@@ -1,2 +0,0 @@
-mod deserialize;
-pub use deserialize::Deserialize;
diff --git a/dhall/src/lib.rs b/dhall/src/lib.rs
index c25fc82..29da609 100644
--- a/dhall/src/lib.rs
+++ b/dhall/src/lib.rs
@@ -128,6 +128,5 @@ pub(crate) mod api;
pub(crate) mod core;
pub mod error;
pub(crate) mod phase;
-pub(crate) use api::traits;
pub use api::*;
diff --git a/dhall/src/phase/mod.rs b/dhall/src/phase/mod.rs
index 5262a27..d7cec67 100644
--- a/dhall/src/phase/mod.rs
+++ b/dhall/src/phase/mod.rs
@@ -50,7 +50,7 @@ pub(crate) enum Typed {
pub(crate) struct Normalized(pub(crate) Typed);
#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct Type(pub(crate) Typed);
+pub(crate) struct Type(pub(crate) Typed);
impl Parsed {
pub fn parse_file(f: &Path) -> Result<Parsed, Error> {
@@ -202,9 +202,6 @@ impl Type {
}
impl Normalized {
- pub(crate) fn to_expr(&self) -> NormalizedSubExpr {
- self.0.to_expr()
- }
#[allow(dead_code)]
pub(crate) fn to_expr_alpha(&self) -> NormalizedSubExpr {
self.0.to_expr_alpha()
@@ -212,9 +209,6 @@ impl Normalized {
pub(crate) fn to_value(&self) -> Value {
self.0.to_value()
}
- pub(crate) fn to_type(&self) -> Type {
- self.0.to_type()
- }
pub(crate) fn into_typed(self) -> Typed {
self.0
}
diff --git a/dhall/src/tests.rs b/dhall/src/tests.rs
index a958e48..76e2e26 100644
--- a/dhall/src/tests.rs
+++ b/dhall/src/tests.rs
@@ -108,7 +108,7 @@ pub fn run_test(
// Round-trip pretty-printer
let expr_string = expr.to_string();
- let expr: Parsed = crate::de::from_str(&expr_string, None)?;
+ let expr: Parsed = Parsed::parse_str(&expr_string)?;
assert_eq!(expr, expected);
return Ok(());
generated by cgit v1.2.3 (git 2.25.1) at 2024-12-25 20:06:14 +0000