Reduce api surface of dhall crate

Helps detect unused code

4 files changed, 45 insertions, 52 deletions

diff --git a/dhall/src/core/context.rs b/dhall/src/core/context.rs
index 8d14415..9230a2e 100644
--- a/dhall/src/core/context.rs
+++ b/dhall/src/core/context.rs
@@ -10,19 +10,19 @@ use crate::error::TypeError;
 use crate::phase::{Type, Typed};
 
 #[derive(Debug, Clone)]
-pub enum CtxItem<T> {
+enum CtxItem<T> {
     Kept(AlphaVar, T),
     Replaced(Thunk, T),
 }
 
 #[derive(Debug, Clone)]
-pub struct Context<T>(Rc<Vec<(Label, CtxItem<T>)>>);
+struct Context<T>(Rc<Vec<(Label, CtxItem<T>)>>);
 
 #[derive(Debug, Clone)]
-pub struct NormalizationContext(Context<()>);
+pub(crate) struct NormalizationContext(Context<()>);
 
 #[derive(Debug, Clone)]
-pub struct TypecheckContext(Context<Type>);
+pub(crate) struct TypecheckContext(Context<Type>);
 
 impl<T> Context<T> {
     pub fn new() -> Self {
diff --git a/dhall/src/core/thunk.rs b/dhall/src/core/thunk.rs
index 14d8792..54a5442 100644
--- a/dhall/src/core/thunk.rs
+++ b/dhall/src/core/thunk.rs
@@ -115,21 +115,21 @@ impl ThunkInternal {
 }
 
 impl Thunk {
-    pub fn new(ctx: NormalizationContext, e: InputSubExpr) -> Thunk {
+    pub(crate) fn new(ctx: NormalizationContext, e: InputSubExpr) -> Thunk {
         ThunkInternal::Unnormalized(ctx, e).into_thunk()
     }
 
-    pub fn from_value(v: Value) -> Thunk {
+    pub(crate) fn from_value(v: Value) -> Thunk {
         ThunkInternal::Value(WHNF, v).into_thunk()
     }
 
-    pub fn from_partial_expr(e: ExprF<Thunk, Normalized>) -> Thunk {
+    pub(crate) fn from_partial_expr(e: ExprF<Thunk, Normalized>) -> Thunk {
         ThunkInternal::PartialExpr(e).into_thunk()
     }
 
     // Normalizes contents to normal form; faster than `normalize_nf` if
     // no one else shares this thunk
-    pub fn normalize_mut(&mut self) {
+    pub(crate) fn normalize_mut(&mut self) {
         match Rc::get_mut(&mut self.0) {
             // Mutate directly if sole owner
             Some(refcell) => RefCell::get_mut(refcell).normalize_nf(),
@@ -167,37 +167,37 @@ impl Thunk {
 
     // WARNING: avoid normalizing any thunk while holding on to this ref
     // or you could run into BorrowMut panics
-    pub fn normalize_nf(&self) -> Ref<Value> {
+    pub(crate) fn normalize_nf(&self) -> Ref<Value> {
         self.do_normalize_nf();
         Ref::map(self.0.borrow(), ThunkInternal::as_nf)
     }
 
     // WARNING: avoid normalizing any thunk while holding on to this ref
     // or you could run into BorrowMut panics
-    pub fn as_value(&self) -> Ref<Value> {
+    pub(crate) fn as_value(&self) -> Ref<Value> {
         self.do_normalize_whnf();
         Ref::map(self.0.borrow(), ThunkInternal::as_whnf)
     }
 
-    pub fn to_value(&self) -> Value {
+    pub(crate) fn to_value(&self) -> Value {
         self.as_value().clone()
     }
 
-    pub fn normalize_to_expr_maybe_alpha(&self, alpha: bool) -> OutputSubExpr {
+    pub(crate) fn normalize_to_expr_maybe_alpha(&self, alpha: bool) -> OutputSubExpr {
         self.normalize_nf().normalize_to_expr_maybe_alpha(alpha)
     }
 
-    pub fn app_val(&self, val: Value) -> Value {
+    pub(crate) fn app_val(&self, val: Value) -> Value {
         self.app_thunk(val.into_thunk())
     }
 
-    pub fn app_thunk(&self, th: Thunk) -> Value {
+    pub(crate) fn app_thunk(&self, th: Thunk) -> Value {
         apply_any(self.clone(), th)
     }
 }
 
 impl TypedThunk {
-    pub fn from_value(v: Value) -> TypedThunk {
+    pub(crate) fn from_value(v: Value) -> TypedThunk {
         TypedThunk::from_thunk(Thunk::from_value(v))
     }
 
@@ -205,11 +205,11 @@ impl TypedThunk {
         TypedThunk::from_thunk_untyped(th)
     }
 
-    pub fn from_type(t: Type) -> TypedThunk {
+    pub(crate) fn from_type(t: Type) -> TypedThunk {
         t.into_typethunk()
     }
 
-    pub fn normalize_nf(&self) -> Value {
+    pub(crate) fn normalize_nf(&self) -> Value {
         match self {
             TypedThunk::Const(c) => Value::Const(*c),
             TypedThunk::Untyped(thunk) | TypedThunk::Typed(thunk, _) => {
@@ -218,53 +218,53 @@ impl TypedThunk {
         }
     }
 
-    pub fn to_typed(&self) -> Typed {
+    pub(crate) fn to_typed(&self) -> Typed {
         self.clone().into_typed()
     }
 
-    pub fn normalize_to_expr_maybe_alpha(&self, alpha: bool) -> OutputSubExpr {
+    pub(crate) fn normalize_to_expr_maybe_alpha(&self, alpha: bool) -> OutputSubExpr {
         self.normalize_nf().normalize_to_expr_maybe_alpha(alpha)
     }
 
-    pub fn from_thunk_and_type(th: Thunk, t: Type) -> Self {
+    pub(crate) fn from_thunk_and_type(th: Thunk, t: Type) -> Self {
         TypedThunk::Typed(th, Box::new(t))
     }
-    pub fn from_thunk_untyped(th: Thunk) -> Self {
+    pub(crate) fn from_thunk_untyped(th: Thunk) -> Self {
         TypedThunk::Untyped(th)
     }
-    pub fn from_const(c: Const) -> Self {
+    pub(crate) fn from_const(c: Const) -> Self {
         TypedThunk::Const(c)
     }
-    pub fn from_value_untyped(v: Value) -> Self {
+    pub(crate) fn from_value_untyped(v: Value) -> Self {
         TypedThunk::from_thunk_untyped(Thunk::from_value(v))
     }
 
     // TODO: Avoid cloning if possible
-    pub fn to_value(&self) -> Value {
+    pub(crate) fn to_value(&self) -> Value {
         match self {
             TypedThunk::Untyped(th) | TypedThunk::Typed(th, _) => th.to_value(),
             TypedThunk::Const(c) => Value::Const(*c),
         }
     }
-    pub fn to_expr(&self) -> NormalizedSubExpr {
+    pub(crate) fn to_expr(&self) -> NormalizedSubExpr {
         self.to_value().normalize_to_expr()
     }
-    pub fn to_expr_alpha(&self) -> NormalizedSubExpr {
+    pub(crate) fn to_expr_alpha(&self) -> NormalizedSubExpr {
         self.to_value().normalize_to_expr_maybe_alpha(true)
     }
-    pub fn to_thunk(&self) -> Thunk {
+    pub(crate) fn to_thunk(&self) -> Thunk {
         match self {
             TypedThunk::Untyped(th) | TypedThunk::Typed(th, _) => th.clone(),
             TypedThunk::Const(c) => Thunk::from_value(Value::Const(*c)),
         }
     }
-    pub fn to_type(&self) -> Type {
+    pub(crate) fn to_type(&self) -> Type {
         self.clone().into_typed().into_type()
     }
-    pub fn into_typed(self) -> Typed {
+    pub(crate) fn into_typed(self) -> Typed {
         Typed::from_typethunk(self)
     }
-    pub fn as_const(&self) -> Option<Const> {
+    pub(crate) fn as_const(&self) -> Option<Const> {
         // TODO: avoid clone
         match &self.to_value() {
             Value::Const(c) => Some(*c),
@@ -272,7 +272,7 @@ impl TypedThunk {
         }
     }
 
-    pub fn normalize_mut(&mut self) {
+    pub(crate) fn normalize_mut(&mut self) {
         match self {
             TypedThunk::Untyped(th) | TypedThunk::Typed(th, _) => {
                 th.normalize_mut()
@@ -281,7 +281,7 @@ impl TypedThunk {
         }
     }
 
-    pub fn get_type(&self) -> Result<Cow<'_, Type>, TypeError> {
+    pub(crate) fn get_type(&self) -> Result<Cow<'_, Type>, TypeError> {
         match self {
             TypedThunk::Untyped(_) => Err(TypeError::new(
                 &TypecheckContext::new(),
diff --git a/dhall/src/core/value.rs b/dhall/src/core/value.rs
index 19be56a..61a8eea 100644
--- a/dhall/src/core/value.rs
+++ b/dhall/src/core/value.rs
@@ -56,17 +56,17 @@ pub enum Value {
 }
 
 impl Value {
-    pub fn into_thunk(self) -> Thunk {
+    pub(crate) fn into_thunk(self) -> Thunk {
         Thunk::from_value(self)
     }
 
     /// Convert the value to a fully normalized syntactic expression
-    pub fn normalize_to_expr(&self) -> OutputSubExpr {
+    pub(crate) fn normalize_to_expr(&self) -> OutputSubExpr {
         self.normalize_to_expr_maybe_alpha(false)
     }
     /// Convert the value to a fully normalized syntactic expression. Also alpha-normalize
     /// if alpha is `true`
-    pub fn normalize_to_expr_maybe_alpha(&self, alpha: bool) -> OutputSubExpr {
+    pub(crate) fn normalize_to_expr_maybe_alpha(&self, alpha: bool) -> OutputSubExpr {
         match self {
             Value::Lam(x, t, e) => rc(ExprF::Lam(
                 x.to_label_maybe_alpha(alpha),
@@ -179,14 +179,7 @@ impl Value {
         }
     }
 
-    // Deprecated
-    pub fn normalize(&self) -> Value {
-        let mut v = self.clone();
-        v.normalize_mut();
-        v
-    }
-
-    pub fn normalize_mut(&mut self) {
+    pub(crate) fn normalize_mut(&mut self) {
         match self {
             Value::Var(_)
             | Value::Const(_)
@@ -264,12 +257,12 @@ impl Value {
     }
 
     /// Apply to a value
-    pub fn app(self, val: Value) -> Value {
+    pub(crate) fn app(self, val: Value) -> Value {
         self.app_val(val)
     }
 
     /// Apply to a value
-    pub fn app_val(self, val: Value) -> Value {
+    pub(crate) fn app_val(self, val: Value) -> Value {
         self.app_thunk(val.into_thunk())
     }
 
diff --git a/dhall/src/core/var.rs b/dhall/src/core/var.rs
index d53c194..4ef1b93 100644
--- a/dhall/src/core/var.rs
+++ b/dhall/src/core/var.rs
@@ -16,7 +16,7 @@ pub struct AlphaVar {
 #[derive(Clone, Eq)]
 pub struct AlphaLabel(Label);
 
-pub trait Shift: Sized {
+pub(crate) trait Shift: Sized {
     // Shift an expression to move it around binders without changing the meaning of its free
     // variables. Shift by 1 to move an expression under a binder. Shift by -1 to extract an
     // expression from under a binder, if the expression does not refer to that bound variable.
@@ -50,24 +50,24 @@ pub trait Shift: Sized {
     }
 }
 
-pub trait Subst<T> {
+pub(crate) trait Subst<T> {
     fn subst_shift(&self, var: &AlphaVar, val: &T) -> Self;
 }
 
 impl AlphaVar {
-    pub fn to_var(&self, alpha: bool) -> V<Label> {
+    pub(crate) fn to_var(&self, alpha: bool) -> V<Label> {
         match (alpha, &self.alpha) {
             (true, Some(x)) => V("_".into(), x.1),
             _ => self.normal.clone(),
         }
     }
-    pub fn from_var(normal: V<Label>) -> Self {
+    pub(crate) fn from_var(normal: V<Label>) -> Self {
         AlphaVar {
             normal,
             alpha: None,
         }
     }
-    pub fn from_var_and_alpha(normal: V<Label>, alpha: usize) -> Self {
+    pub(crate) fn from_var_and_alpha(normal: V<Label>, alpha: usize) -> Self {
         AlphaVar {
             normal,
             alpha: Some(V((), alpha)),
@@ -76,14 +76,14 @@ impl AlphaVar {
 }
 
 impl AlphaLabel {
-    pub fn to_label_maybe_alpha(&self, alpha: bool) -> Label {
+    pub(crate) fn to_label_maybe_alpha(&self, alpha: bool) -> Label {
         if alpha {
             "_".into()
         } else {
             self.to_label()
         }
     }
-    pub fn to_label(&self) -> Label {
+    pub(crate) fn to_label(&self) -> Label {
         self.clone().into()
     }
 }