Limit dependency on Normalized

2 files changed, 42 insertions, 84 deletions

diff --git a/dhall/src/lib.rs b/dhall/src/lib.rs
index 7300d88..0e2ec82 100644
--- a/dhall/src/lib.rs
+++ b/dhall/src/lib.rs
@@ -16,15 +16,12 @@ use std::fmt::Display;
 use std::path::Path;
 use url::Url;
 
-use crate::error::{EncodeError, Error, TypeError};
+use crate::error::{Error, TypeError};
 use crate::semantics::parse;
 use crate::semantics::resolve;
 use crate::semantics::resolve::ImportLocation;
-use crate::semantics::{
-    typecheck, typecheck_with, Hir, Nir, NirKind, Tir, Type,
-};
-use crate::syntax::binary;
-use crate::syntax::{Builtin, Expr};
+use crate::semantics::{typecheck, typecheck_with, Hir, Nir, Tir, Type};
+use crate::syntax::Expr;
 
 pub(crate) type ParsedExpr = Expr;
 pub(crate) type DecodedExpr = Expr;
@@ -57,8 +54,9 @@ pub(crate) struct Normalized(Nir);
 pub struct Value {
     /// Invariant: in normal form
     pub(crate) hir: Hir,
-    simple_val: Option<SimpleValue>,
-    simple_ty: Option<SimpleType>,
+    /// Cached conversions because they are annoying to construct from Hir.
+    pub(crate) as_simple_val: Option<SimpleValue>,
+    pub(crate) as_simple_ty: Option<SimpleType>,
 }
 
 /// Controls conversion from `Nir` to `Expr`
@@ -135,14 +133,11 @@ impl Typed {
 }
 
 impl Normalized {
-    pub fn encode(&self) -> Result<Vec<u8>, EncodeError> {
-        binary::encode(&self.to_expr())
-    }
     pub fn to_value(&self) -> Value {
         Value {
             hir: self.to_hir(),
-            simple_val: self.0.to_simple_value(),
-            simple_ty: self.0.to_simple_type(),
+            as_simple_val: self.0.to_simple_value(),
+            as_simple_ty: self.0.to_simple_type(),
         }
     }
 
@@ -158,46 +153,6 @@ impl Normalized {
     pub(crate) fn to_expr_alpha(&self) -> NormalizedExpr {
         self.0.to_expr(ToExprOptions { alpha: true })
     }
-    pub(crate) fn to_nir(&self) -> Nir {
-        self.0.clone()
-    }
-    pub(crate) fn into_nir(self) -> Nir {
-        self.0
-    }
-
-    pub(crate) fn from_kind(v: NirKind) -> Self {
-        Normalized(Nir::from_kind(v))
-    }
-    pub(crate) fn from_nir(th: Nir) -> Self {
-        Normalized(th)
-    }
-
-    pub(crate) fn make_builtin_type(b: Builtin) -> Self {
-        Normalized::from_nir(Nir::from_builtin(b))
-    }
-    pub(crate) fn make_optional_type(t: Normalized) -> Self {
-        Normalized::from_nir(
-            Nir::from_builtin(Builtin::Optional).app(t.to_nir()),
-        )
-    }
-    pub(crate) fn make_list_type(t: Normalized) -> Self {
-        Normalized::from_nir(Nir::from_builtin(Builtin::List).app(t.to_nir()))
-    }
-    pub(crate) fn make_record_type(
-        kts: impl Iterator<Item = (String, Normalized)>,
-    ) -> Self {
-        Normalized::from_kind(NirKind::RecordType(
-            kts.map(|(k, t)| (k.into(), t.into_nir())).collect(),
-        ))
-    }
-    pub(crate) fn make_union_type(
-        kts: impl Iterator<Item = (String, Option<Normalized>)>,
-    ) -> Self {
-        Normalized::from_kind(NirKind::UnionType(
-            kts.map(|(k, t)| (k.into(), t.map(|t| t.into_nir())))
-                .collect(),
-        ))
-    }
 }
 
 impl Value {
@@ -217,11 +172,11 @@ impl Value {
 
     /// Converts a Value into a SimpleValue.
     pub fn to_simple_value(&self) -> Option<SimpleValue> {
-        self.simple_val.clone()
+        self.as_simple_val.clone()
     }
     /// Converts a Value into a SimpleType.
     pub fn to_simple_type(&self) -> Option<SimpleType> {
-        self.simple_ty.clone()
+        self.as_simple_ty.clone()
     }
 
     /// Converts a value back to the corresponding AST expression.
@@ -253,17 +208,6 @@ macro_rules! derive_traits_for_wrapper_struct {
 
 derive_traits_for_wrapper_struct!(Parsed);
 
-impl std::hash::Hash for Normalized {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: std::hash::Hasher,
-    {
-        if let Ok(vec) = self.encode() {
-            vec.hash(state)
-        }
-    }
-}
-
 impl From<Parsed> for NormalizedExpr {
     fn from(other: Parsed) -> Self {
         other.to_expr()
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(),
             ),
-        }
+        })
     }
 }