From 52f9ecfc4dac65d305fd920e8c7f748889a0804f Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Mon, 12 Aug 2019 23:24:48 +0200
Subject: Move api into its own crate

---
 serde_dhall/src/static_type.rs | 93 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 93 insertions(+)
 create mode 100644 serde_dhall/src/static_type.rs

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

diff --git a/serde_dhall/src/static_type.rs b/serde_dhall/src/static_type.rs
new file mode 100644
index 0000000..13d5d70
--- /dev/null
+++ b/serde_dhall/src/static_type.rs
@@ -0,0 +1,93 @@
+use dhall_syntax::{Builtin, Integer, Natural};
+
+use crate::Type;
+
+/// A Rust type that can be represented as a Dhall type.
+///
+/// A typical example is `Option<bool>`,
+/// represented by the dhall expression `Optional Bool`.
+///
+/// This trait can and should be automatically derived.
+///
+/// The representation needs to be independent of the value.
+/// For this reason, something like `HashMap<String, bool>` cannot implement
+/// [StaticType] because each different value would
+/// have a different Dhall record type.
+pub trait StaticType {
+    fn static_type() -> Type;
+}
+
+macro_rules! derive_builtin {
+    ($ty:ty, $builtin:ident) => {
+        impl StaticType for $ty {
+            fn static_type() -> Type {
+                Type::make_builtin_type(Builtin::$builtin)
+            }
+        }
+    };
+}
+
+derive_builtin!(bool, Bool);
+derive_builtin!(Natural, Natural);
+derive_builtin!(u64, Natural);
+derive_builtin!(Integer, Integer);
+derive_builtin!(String, Text);
+
+impl<A, B> StaticType for (A, B)
+where
+    A: StaticType,
+    B: StaticType,
+{
+    fn static_type() -> Type {
+        Type::make_record_type(
+            vec![
+                ("_1".to_owned(), A::static_type()),
+                ("_2".to_owned(), B::static_type()),
+            ]
+            .into_iter(),
+        )
+    }
+}
+
+impl<T, E> StaticType for std::result::Result<T, E>
+where
+    T: StaticType,
+    E: StaticType,
+{
+    fn static_type() -> Type {
+        Type::make_union_type(
+            vec![
+                ("Ok".to_owned(), Some(T::static_type())),
+                ("Err".to_owned(), Some(E::static_type())),
+            ]
+            .into_iter(),
+        )
+    }
+}
+
+impl<T> StaticType for Option<T>
+where
+    T: StaticType,
+{
+    fn static_type() -> Type {
+        Type::make_optional_type(T::static_type())
+    }
+}
+
+impl<T> StaticType for Vec<T>
+where
+    T: StaticType,
+{
+    fn static_type() -> Type {
+        Type::make_list_type(T::static_type())
+    }
+}
+
+impl<'a, T> StaticType for &'a T
+where
+    T: StaticType,
+{
+    fn static_type() -> Type {
+        T::static_type()
+    }
+}
-- 
cgit v1.2.3


From 1ea8b10051d29c634399304273d6ee565d039bc2 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Tue, 13 Aug 2019 15:25:53 +0200
Subject: Merge `Type` and `Value` in serde_dhall

There was no point in separating them
---
 serde_dhall/src/static_type.rs | 26 +++++++++++++-------------
 1 file changed, 13 insertions(+), 13 deletions(-)

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

diff --git a/serde_dhall/src/static_type.rs b/serde_dhall/src/static_type.rs
index 13d5d70..67a7bc4 100644
--- a/serde_dhall/src/static_type.rs
+++ b/serde_dhall/src/static_type.rs
@@ -1,6 +1,6 @@
 use dhall_syntax::{Builtin, Integer, Natural};
 
-use crate::Type;
+use crate::Value;
 
 /// A Rust type that can be represented as a Dhall type.
 ///
@@ -14,14 +14,14 @@ use crate::Type;
 /// [StaticType] because each different value would
 /// have a different Dhall record type.
 pub trait StaticType {
-    fn static_type() -> Type;
+    fn static_type() -> Value;
 }
 
 macro_rules! derive_builtin {
     ($ty:ty, $builtin:ident) => {
         impl StaticType for $ty {
-            fn static_type() -> Type {
-                Type::make_builtin_type(Builtin::$builtin)
+            fn static_type() -> Value {
+                Value::make_builtin_type(Builtin::$builtin)
             }
         }
     };
@@ -38,8 +38,8 @@ where
     A: StaticType,
     B: StaticType,
 {
-    fn static_type() -> Type {
-        Type::make_record_type(
+    fn static_type() -> Value {
+        Value::make_record_type(
             vec![
                 ("_1".to_owned(), A::static_type()),
                 ("_2".to_owned(), B::static_type()),
@@ -54,8 +54,8 @@ where
     T: StaticType,
     E: StaticType,
 {
-    fn static_type() -> Type {
-        Type::make_union_type(
+    fn static_type() -> Value {
+        Value::make_union_type(
             vec![
                 ("Ok".to_owned(), Some(T::static_type())),
                 ("Err".to_owned(), Some(E::static_type())),
@@ -69,8 +69,8 @@ impl<T> StaticType for Option<T>
 where
     T: StaticType,
 {
-    fn static_type() -> Type {
-        Type::make_optional_type(T::static_type())
+    fn static_type() -> Value {
+        Value::make_optional_type(T::static_type())
     }
 }
 
@@ -78,8 +78,8 @@ impl<T> StaticType for Vec<T>
 where
     T: StaticType,
 {
-    fn static_type() -> Type {
-        Type::make_list_type(T::static_type())
+    fn static_type() -> Value {
+        Value::make_list_type(T::static_type())
     }
 }
 
@@ -87,7 +87,7 @@ impl<'a, T> StaticType for &'a T
 where
     T: StaticType,
 {
-    fn static_type() -> Type {
+    fn static_type() -> Value {
         T::static_type()
     }
 }
-- 
cgit v1.2.3