From 42d0f8100462f8a17a3ba1b86664310cdb71dfdc Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Sat, 6 Apr 2019 17:55:43 +0200
Subject: Rename some modules

---
 dhall/src/dhall_type.rs   | 77 -----------------------------------------------
 dhall/src/lib.rs          |  6 ++--
 dhall/src/traits.rs       | 77 +++++++++++++++++++++++++++++++++++++++++++++++
 dhall/tests/dhall_type.rs | 53 --------------------------------
 dhall/tests/traits.rs     | 53 ++++++++++++++++++++++++++++++++
 5 files changed, 133 insertions(+), 133 deletions(-)
 delete mode 100644 dhall/src/dhall_type.rs
 create mode 100644 dhall/src/traits.rs
 delete mode 100644 dhall/tests/dhall_type.rs
 create mode 100644 dhall/tests/traits.rs

(limited to 'dhall')

diff --git a/dhall/src/dhall_type.rs b/dhall/src/dhall_type.rs
deleted file mode 100644
index 64e07d9..0000000
--- a/dhall/src/dhall_type.rs
+++ /dev/null
@@ -1,77 +0,0 @@
-use dhall_core::*;
-use dhall_generator::*;
-
-#[derive(Debug, Clone)]
-pub enum ConversionError {}
-
-pub trait StaticType {
-    fn get_type() -> DhallExpr;
-    // fn as_dhall(&self) -> DhallExpr;
-    // fn from_dhall(e: DhallExpr) -> Result<Self, DhallConversionError>;
-}
-
-impl StaticType for bool {
-    fn get_type() -> DhallExpr {
-        dhall_expr!(Bool)
-    }
-}
-
-impl StaticType for Natural {
-    fn get_type() -> DhallExpr {
-        dhall_expr!(Natural)
-    }
-}
-
-impl StaticType for Integer {
-    fn get_type() -> DhallExpr {
-        dhall_expr!(Integer)
-    }
-}
-
-impl StaticType for String {
-    fn get_type() -> DhallExpr {
-        dhall_expr!(Text)
-    }
-}
-
-impl<A: StaticType, B: StaticType> StaticType for (A, B) {
-    fn get_type() -> DhallExpr {
-        let ta = A::get_type();
-        let tb = B::get_type();
-        dhall_expr!({ _1: ta, _2: tb })
-    }
-}
-
-impl<T: StaticType> StaticType for Option<T> {
-    fn get_type() -> DhallExpr {
-        let t = T::get_type();
-        dhall_expr!(Optional t)
-    }
-}
-
-impl<T: StaticType> StaticType for Vec<T> {
-    fn get_type() -> DhallExpr {
-        let t = T::get_type();
-        dhall_expr!(List t)
-    }
-}
-
-impl<'a, T: StaticType> StaticType for &'a T {
-    fn get_type() -> DhallExpr {
-        T::get_type()
-    }
-}
-
-impl<T> StaticType for std::marker::PhantomData<T> {
-    fn get_type() -> DhallExpr {
-        dhall_expr!({})
-    }
-}
-
-impl<T: StaticType, E: StaticType> StaticType for Result<T, E> {
-    fn get_type() -> DhallExpr {
-        let tt = T::get_type();
-        let te = E::get_type();
-        dhall_expr!(< Ok: tt | Err: te>)
-    }
-}
diff --git a/dhall/src/lib.rs b/dhall/src/lib.rs
index 5a155c8..7439312 100644
--- a/dhall/src/lib.rs
+++ b/dhall/src/lib.rs
@@ -10,14 +10,14 @@
 mod normalize;
 pub use crate::normalize::*;
 pub mod binary;
-mod dhall_type;
 pub mod imports;
+mod traits;
 pub mod typecheck;
-pub use crate::dhall_type::*;
+pub use crate::imports::*;
+pub use crate::traits::*;
 pub use dhall_generator::expr;
 pub use dhall_generator::subexpr;
 pub use dhall_generator::StaticType;
-pub use crate::imports::*;
 
 // pub struct DhallExpr(dhall_core::DhallExpr);
 
diff --git a/dhall/src/traits.rs b/dhall/src/traits.rs
new file mode 100644
index 0000000..64e07d9
--- /dev/null
+++ b/dhall/src/traits.rs
@@ -0,0 +1,77 @@
+use dhall_core::*;
+use dhall_generator::*;
+
+#[derive(Debug, Clone)]
+pub enum ConversionError {}
+
+pub trait StaticType {
+    fn get_type() -> DhallExpr;
+    // fn as_dhall(&self) -> DhallExpr;
+    // fn from_dhall(e: DhallExpr) -> Result<Self, DhallConversionError>;
+}
+
+impl StaticType for bool {
+    fn get_type() -> DhallExpr {
+        dhall_expr!(Bool)
+    }
+}
+
+impl StaticType for Natural {
+    fn get_type() -> DhallExpr {
+        dhall_expr!(Natural)
+    }
+}
+
+impl StaticType for Integer {
+    fn get_type() -> DhallExpr {
+        dhall_expr!(Integer)
+    }
+}
+
+impl StaticType for String {
+    fn get_type() -> DhallExpr {
+        dhall_expr!(Text)
+    }
+}
+
+impl<A: StaticType, B: StaticType> StaticType for (A, B) {
+    fn get_type() -> DhallExpr {
+        let ta = A::get_type();
+        let tb = B::get_type();
+        dhall_expr!({ _1: ta, _2: tb })
+    }
+}
+
+impl<T: StaticType> StaticType for Option<T> {
+    fn get_type() -> DhallExpr {
+        let t = T::get_type();
+        dhall_expr!(Optional t)
+    }
+}
+
+impl<T: StaticType> StaticType for Vec<T> {
+    fn get_type() -> DhallExpr {
+        let t = T::get_type();
+        dhall_expr!(List t)
+    }
+}
+
+impl<'a, T: StaticType> StaticType for &'a T {
+    fn get_type() -> DhallExpr {
+        T::get_type()
+    }
+}
+
+impl<T> StaticType for std::marker::PhantomData<T> {
+    fn get_type() -> DhallExpr {
+        dhall_expr!({})
+    }
+}
+
+impl<T: StaticType, E: StaticType> StaticType for Result<T, E> {
+    fn get_type() -> DhallExpr {
+        let tt = T::get_type();
+        let te = E::get_type();
+        dhall_expr!(< Ok: tt | Err: te>)
+    }
+}
diff --git a/dhall/tests/dhall_type.rs b/dhall/tests/dhall_type.rs
deleted file mode 100644
index ac6b5e6..0000000
--- a/dhall/tests/dhall_type.rs
+++ /dev/null
@@ -1,53 +0,0 @@
-#![feature(proc_macro_hygiene)]
-use dhall::StaticType;
-use dhall_generator::dhall_expr;
-
-#[test]
-fn test_dhall_type() {
-    assert_eq!(bool::get_type(), dhall_expr!(Bool));
-    assert_eq!(String::get_type(), dhall_expr!(Text));
-    assert_eq!(
-        <(bool, Option<String>)>::get_type(),
-        dhall_expr!({ _1: Bool, _2: Optional Text })
-    );
-
-    #[derive(dhall::StaticType)]
-    #[allow(dead_code)]
-    struct A {
-        field1: bool,
-        field2: Option<bool>,
-    }
-    assert_eq!(
-        <A as dhall::StaticType>::get_type(),
-        dhall_expr!({ field1: Bool, field2: Optional Bool })
-    );
-
-    #[derive(StaticType)]
-    #[allow(dead_code)]
-    struct B<'a, T: 'a> {
-        field1: &'a T,
-        field2: Option<T>,
-    }
-    assert_eq!(<B<'static, bool>>::get_type(), A::get_type());
-
-    #[derive(StaticType)]
-    #[allow(dead_code)]
-    struct C<T>(T, Option<String>);
-    assert_eq!(<C<bool>>::get_type(), <(bool, Option<String>)>::get_type());
-
-    #[derive(StaticType)]
-    #[allow(dead_code)]
-    struct D();
-    assert_eq!(
-        <C<D>>::get_type(),
-        dhall_expr!({ _1: {}, _2: Optional Text })
-    );
-
-    #[derive(StaticType)]
-    #[allow(dead_code)]
-    enum E<T> {
-        A(T),
-        B(String),
-    };
-    assert_eq!(<E<bool>>::get_type(), dhall_expr!(< A: Bool | B: Text >));
-}
diff --git a/dhall/tests/traits.rs b/dhall/tests/traits.rs
new file mode 100644
index 0000000..ac6b5e6
--- /dev/null
+++ b/dhall/tests/traits.rs
@@ -0,0 +1,53 @@
+#![feature(proc_macro_hygiene)]
+use dhall::StaticType;
+use dhall_generator::dhall_expr;
+
+#[test]
+fn test_dhall_type() {
+    assert_eq!(bool::get_type(), dhall_expr!(Bool));
+    assert_eq!(String::get_type(), dhall_expr!(Text));
+    assert_eq!(
+        <(bool, Option<String>)>::get_type(),
+        dhall_expr!({ _1: Bool, _2: Optional Text })
+    );
+
+    #[derive(dhall::StaticType)]
+    #[allow(dead_code)]
+    struct A {
+        field1: bool,
+        field2: Option<bool>,
+    }
+    assert_eq!(
+        <A as dhall::StaticType>::get_type(),
+        dhall_expr!({ field1: Bool, field2: Optional Bool })
+    );
+
+    #[derive(StaticType)]
+    #[allow(dead_code)]
+    struct B<'a, T: 'a> {
+        field1: &'a T,
+        field2: Option<T>,
+    }
+    assert_eq!(<B<'static, bool>>::get_type(), A::get_type());
+
+    #[derive(StaticType)]
+    #[allow(dead_code)]
+    struct C<T>(T, Option<String>);
+    assert_eq!(<C<bool>>::get_type(), <(bool, Option<String>)>::get_type());
+
+    #[derive(StaticType)]
+    #[allow(dead_code)]
+    struct D();
+    assert_eq!(
+        <C<D>>::get_type(),
+        dhall_expr!({ _1: {}, _2: Optional Text })
+    );
+
+    #[derive(StaticType)]
+    #[allow(dead_code)]
+    enum E<T> {
+        A(T),
+        B(String),
+    };
+    assert_eq!(<E<bool>>::get_type(), dhall_expr!(< A: Bool | B: Text >));
+}
-- 
cgit v1.2.3