1 files changed, 32 insertions, 18 deletions
diff --git a/dhall/src/simple.rs b/dhall/src/simple.rs
index 014053e..7e7e459 100644
--- a/dhall/src/simple.rs
+++ b/dhall/src/simple.rs
@@ -1,7 +1,8 @@
 use std::collections::BTreeMap;
 
-use crate::syntax::{Builtin, LitKind};
-use crate::{Normalized, Value};
+use crate::semantics::{Hir, HirKind};
+use crate::syntax::{Builtin, ExprKind, LitKind, Span};
+use crate::Value;
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct SimpleValue {
@@ -57,26 +58,39 @@ impl SimpleType {
         self.kind.as_ref()
     }
     pub fn to_value(&self) -> Value {
-        self.clone().into_normalized().to_value()
+        Value {
+            hir: self.to_hir(),
+            as_simple_val: None,
+            as_simple_ty: Some(self.clone()),
+        }
     }
-    fn into_normalized(self) -> Normalized {
-        match *self.kind {
-            STyKind::Bool => Normalized::make_builtin_type(Builtin::Bool),
-            STyKind::Natural => Normalized::make_builtin_type(Builtin::Natural),
-            STyKind::Integer => Normalized::make_builtin_type(Builtin::Integer),
-            STyKind::Double => Normalized::make_builtin_type(Builtin::Double),
-            STyKind::Text => Normalized::make_builtin_type(Builtin::Text),
-            STyKind::Optional(t) => {
-                Normalized::make_optional_type(t.into_normalized())
+    pub(crate) fn to_hir(&self) -> Hir {
+        let hir = |k| Hir::new(HirKind::Expr(k), Span::Artificial);
+        hir(match self.kind() {
+            STyKind::Bool => ExprKind::Builtin(Builtin::Bool),
+            STyKind::Natural => ExprKind::Builtin(Builtin::Natural),
+            STyKind::Integer => ExprKind::Builtin(Builtin::Integer),
+            STyKind::Double => ExprKind::Builtin(Builtin::Double),
+            STyKind::Text => ExprKind::Builtin(Builtin::Text),
+            STyKind::Optional(t) => ExprKind::App(
+                hir(ExprKind::Builtin(Builtin::Optional)),
+                t.to_hir(),
+            ),
+            STyKind::List(t) => {
+                ExprKind::App(hir(ExprKind::Builtin(Builtin::List)), t.to_hir())
             }
-            STyKind::List(t) => Normalized::make_list_type(t.into_normalized()),
-            STyKind::Record(kts) => Normalized::make_record_type(
-                kts.into_iter().map(|(k, t)| (k, t.into_normalized())),
+            STyKind::Record(kts) => ExprKind::RecordType(
+                kts.into_iter()
+                    .map(|(k, t)| (k.as_str().into(), t.to_hir()))
+                    .collect(),
             ),
-            STyKind::Union(kts) => Normalized::make_union_type(
+            STyKind::Union(kts) => ExprKind::UnionType(
                 kts.into_iter()
-                    .map(|(k, t)| (k, t.map(|t| t.into_normalized()))),
+                    .map(|(k, t)| {
+                        (k.as_str().into(), t.as_ref().map(|t| t.to_hir()))
+                    })
+                    .collect(),
             ),
-        }
+        })
     }
 }