From b6f57069b75febf1d312a98efcd6544c9db2fe59 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Sat, 4 May 2019 14:19:43 +0200
Subject: Remove dummy lifetimes

---
 dhall/src/expr.rs                | 100 ++++++++++-------------
 dhall/src/imports.rs             |  86 ++++++++++----------
 dhall/src/normalize.rs           |  50 ++++--------
 dhall/src/traits/deserialize.rs  |  10 +--
 dhall/src/traits/dynamic_type.rs |  16 ++--
 dhall/src/traits/static_type.rs  |  40 +++++-----
 dhall/src/typecheck.rs           | 167 +++++++++++++++++----------------------
 dhall/tests/traits.rs            |   2 +-
 dhall_proc_macros/src/derive.rs  |   4 +-
 dhall_syntax/src/parser.rs       | 113 +++++++++++++-------------
 10 files changed, 260 insertions(+), 328 deletions(-)

diff --git a/dhall/src/expr.rs b/dhall/src/expr.rs
index b0b6215..db426ce 100644
--- a/dhall/src/expr.rs
+++ b/dhall/src/expr.rs
@@ -1,19 +1,18 @@
 use crate::imports::ImportRoot;
 use crate::normalize::{Thunk, Value};
 use dhall_syntax::*;
-use std::marker::PhantomData;
 
 macro_rules! derive_other_traits {
     ($ty:ident) => {
-        impl<'a> std::cmp::PartialEq for $ty<'a> {
+        impl std::cmp::PartialEq for $ty {
             fn eq(&self, other: &Self) -> bool {
                 self.0 == other.0
             }
         }
 
-        impl<'a> std::cmp::Eq for $ty<'a> {}
+        impl std::cmp::Eq for $ty {}
 
-        impl<'a> std::fmt::Display for $ty<'a> {
+        impl std::fmt::Display for $ty {
             fn fmt(
                 &self,
                 f: &mut std::fmt::Formatter,
@@ -25,41 +24,33 @@ macro_rules! derive_other_traits {
 }
 
 #[derive(Debug, Clone)]
-pub(crate) struct Parsed<'a>(
-    pub(crate) SubExpr<Span<'a>, Import>,
+pub(crate) struct Parsed(
+    pub(crate) SubExpr<Span, Import>,
     pub(crate) ImportRoot,
 );
 derive_other_traits!(Parsed);
 
 #[derive(Debug, Clone)]
-pub(crate) struct Resolved<'a>(
-    pub(crate) SubExpr<Span<'a>, Normalized<'static>>,
-);
+pub(crate) struct Resolved(pub(crate) SubExpr<Span, Normalized>);
 derive_other_traits!(Resolved);
 
 pub(crate) use self::typed::TypedInternal;
 
 #[derive(Debug, Clone)]
-pub(crate) struct Typed<'a>(
-    pub(crate) TypedInternal,
-    pub(crate) PhantomData<&'a ()>,
-);
+pub(crate) struct Typed(pub(crate) TypedInternal);
 
 #[derive(Debug, Clone)]
-pub(crate) struct Normalized<'a>(
-    pub(crate) TypedInternal,
-    pub(crate) PhantomData<&'a ()>,
-);
+pub(crate) struct Normalized(pub(crate) TypedInternal);
 
-impl<'a> std::cmp::PartialEq for Normalized<'a> {
+impl std::cmp::PartialEq for Normalized {
     fn eq(&self, other: &Self) -> bool {
         self.to_expr() == other.to_expr()
     }
 }
 
-impl<'a> std::cmp::Eq for Normalized<'a> {}
+impl std::cmp::Eq for Normalized {}
 
-impl<'a> std::fmt::Display for Normalized<'a> {
+impl std::fmt::Display for Normalized {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> {
         self.to_expr().fmt(f)
     }
@@ -73,18 +64,17 @@ mod typed {
     };
     use dhall_syntax::{Const, Label, SubExpr, V, X};
     use std::borrow::Cow;
-    use std::marker::PhantomData;
 
     #[derive(Debug, Clone)]
     pub(crate) enum TypedInternal {
         // The `Sort` higher-kinded type doesn't have a type
         Sort,
         // Any other value, along with its type
-        Value(Thunk, Option<Type<'static>>),
+        Value(Thunk, Option<Type>),
     }
 
     impl TypedInternal {
-        pub(crate) fn from_thunk_and_type(th: Thunk, t: Type<'static>) -> Self {
+        pub(crate) fn from_thunk_and_type(th: Thunk, t: Type) -> Self {
             TypedInternal::Value(th, Some(t))
         }
 
@@ -113,22 +103,19 @@ mod typed {
             }
         }
 
-        pub(crate) fn to_type(&self) -> Type<'static> {
+        pub(crate) fn to_type(&self) -> Type {
             match self {
                 TypedInternal::Sort => Type(TypeInternal::Const(Const::Sort)),
                 TypedInternal::Value(th, _) => match &*th.as_value() {
                     Value::Const(c) => Type(TypeInternal::Const(*c)),
-                    _ => Type(TypeInternal::Typed(Box::new(Typed(
-                        self.clone(),
-                        PhantomData,
-                    )))),
+                    _ => {
+                        Type(TypeInternal::Typed(Box::new(Typed(self.clone()))))
+                    }
                 },
             }
         }
 
-        pub(crate) fn get_type(
-            &self,
-        ) -> Result<Cow<'_, Type<'static>>, TypeError> {
+        pub(crate) fn get_type(&self) -> Result<Cow<'_, Type>, TypeError> {
             match self {
                 TypedInternal::Value(_, Some(t)) => Ok(Cow::Borrowed(t)),
                 TypedInternal::Value(_, None) => Err(TypeError::new(
@@ -152,11 +139,7 @@ mod typed {
             }
         }
 
-        pub(crate) fn subst_shift(
-            &self,
-            var: &V<Label>,
-            val: &Typed<'static>,
-        ) -> Self {
+        pub(crate) fn subst_shift(&self, var: &V<Label>, val: &Typed) -> Self {
             match self {
                 TypedInternal::Value(th, t) => TypedInternal::Value(
                     th.subst_shift(var, val),
@@ -175,10 +158,7 @@ mod typed {
 ///
 /// For a more general notion of "type", see [Type].
 #[derive(Debug, Clone)]
-pub struct SimpleType<'a>(
-    pub(crate) SubExpr<X, X>,
-    pub(crate) PhantomData<&'a ()>,
-);
+pub struct SimpleType(pub(crate) SubExpr<X, X>);
 derive_other_traits!(SimpleType);
 
 pub(crate) use crate::typecheck::TypeInternal;
@@ -188,9 +168,9 @@ pub(crate) use crate::typecheck::TypeInternal;
 /// This includes [SimpleType]s but also higher-kinded expressions like
 /// `Type`, `Kind` and `{ x: Type }`.
 #[derive(Debug, Clone, PartialEq, Eq)]
-pub struct Type<'a>(pub(crate) TypeInternal<'a>);
+pub struct Type(pub(crate) TypeInternal);
 
-impl<'a> std::fmt::Display for Type<'a> {
+impl std::fmt::Display for Type {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> {
         self.to_normalized().fmt(f)
     }
@@ -198,31 +178,31 @@ impl<'a> std::fmt::Display for Type<'a> {
 
 // Exposed for the macros
 #[doc(hidden)]
-impl<'a> From<SimpleType<'a>> for SubExpr<X, X> {
-    fn from(x: SimpleType<'a>) -> SubExpr<X, X> {
+impl From<SimpleType> for SubExpr<X, X> {
+    fn from(x: SimpleType) -> SubExpr<X, X> {
         x.0
     }
 }
 
 // Exposed for the macros
 #[doc(hidden)]
-impl<'a> From<SubExpr<X, X>> for SimpleType<'a> {
-    fn from(x: SubExpr<X, X>) -> SimpleType<'a> {
-        SimpleType(x, PhantomData)
+impl From<SubExpr<X, X>> for SimpleType {
+    fn from(x: SubExpr<X, X>) -> SimpleType {
+        SimpleType(x)
     }
 }
 
 // Exposed for the macros
 #[doc(hidden)]
-impl<'a> From<Normalized<'a>> for Typed<'a> {
-    fn from(x: Normalized<'a>) -> Typed<'a> {
-        Typed(x.0, x.1)
+impl From<Normalized> for Typed {
+    fn from(x: Normalized) -> Typed {
+        Typed(x.0)
     }
 }
 
-impl<'a> Normalized<'a> {
-    pub(crate) fn from_thunk_and_type(th: Thunk, t: Type<'static>) -> Self {
-        Normalized(TypedInternal::from_thunk_and_type(th, t), PhantomData)
+impl Normalized {
+    pub(crate) fn from_thunk_and_type(th: Thunk, t: Type) -> Self {
+        Normalized(TypedInternal::from_thunk_and_type(th, t))
     }
     // Deprecated
     pub(crate) fn as_expr(&self) -> SubExpr<X, X> {
@@ -235,19 +215,19 @@ impl<'a> Normalized<'a> {
         self.0.to_value()
     }
     #[allow(dead_code)]
-    pub(crate) fn unnote<'b>(self) -> Normalized<'b> {
-        Normalized(self.0, PhantomData)
+    pub(crate) fn unnote(self) -> Normalized {
+        Normalized(self.0)
     }
 }
 
-impl<'a> Typed<'a> {
-    pub(crate) fn from_thunk_and_type(th: Thunk, t: Type<'static>) -> Self {
-        Typed(TypedInternal::from_thunk_and_type(th, t), PhantomData)
+impl Typed {
+    pub(crate) fn from_thunk_and_type(th: Thunk, t: Type) -> Self {
+        Typed(TypedInternal::from_thunk_and_type(th, t))
     }
     pub(crate) fn from_thunk_untyped(th: Thunk) -> Self {
-        Typed(TypedInternal::from_thunk_untyped(th), PhantomData)
+        Typed(TypedInternal::from_thunk_untyped(th))
     }
     pub(crate) fn const_sort() -> Self {
-        Typed(TypedInternal::Sort, PhantomData)
+        Typed(TypedInternal::Sort)
     }
 }
diff --git a/dhall/src/imports.rs b/dhall/src/imports.rs
index 306d4e6..87642a2 100644
--- a/dhall/src/imports.rs
+++ b/dhall/src/imports.rs
@@ -20,7 +20,7 @@ pub enum ImportRoot {
     LocalDir(PathBuf),
 }
 
-type ImportCache = HashMap<Import, Normalized<'static>>;
+type ImportCache = HashMap<Import, Normalized>;
 
 type ImportStack = Vec<Import>;
 
@@ -29,7 +29,7 @@ fn resolve_import(
     root: &ImportRoot,
     import_cache: &mut ImportCache,
     import_stack: &ImportStack,
-) -> Result<Normalized<'static>, ImportError> {
+) -> Result<Normalized, ImportError> {
     use self::ImportRoot::*;
     use dhall_syntax::FilePrefix::*;
     use dhall_syntax::ImportLocation::*;
@@ -56,7 +56,7 @@ fn load_import(
     f: &Path,
     import_cache: &mut ImportCache,
     import_stack: &ImportStack,
-) -> Result<Normalized<'static>, Error> {
+) -> Result<Normalized, Error> {
     Ok(
         do_resolve_expr(Parsed::parse_file(f)?, import_cache, import_stack)?
             .typecheck()?
@@ -64,57 +64,51 @@ fn load_import(
     )
 }
 
-fn do_resolve_expr<'a>(
-    Parsed(expr, root): Parsed<'a>,
+fn do_resolve_expr(
+    Parsed(expr, root): Parsed,
     import_cache: &mut ImportCache,
     import_stack: &ImportStack,
-) -> Result<Resolved<'a>, ImportError> {
-    let resolve =
-        |import: &Import| -> Result<Normalized<'static>, ImportError> {
-            if import_stack.contains(import) {
-                return Err(ImportError::ImportCycle(
-                    import_stack.clone(),
-                    import.clone(),
-                ));
-            }
-            match import_cache.get(import) {
-                Some(expr) => Ok(expr.clone()),
-                None => {
-                    // Copy the import stack and push the current import
-                    let mut import_stack = import_stack.clone();
-                    import_stack.push(import.clone());
-
-                    // Resolve the import recursively
-                    let expr = resolve_import(
-                        import,
-                        &root,
-                        import_cache,
-                        &import_stack,
-                    )?;
-
-                    // Add the import to the cache
-                    import_cache.insert(import.clone(), expr.clone());
-                    Ok(expr)
-                }
+) -> Result<Resolved, ImportError> {
+    let resolve = |import: &Import| -> Result<Normalized, ImportError> {
+        if import_stack.contains(import) {
+            return Err(ImportError::ImportCycle(
+                import_stack.clone(),
+                import.clone(),
+            ));
+        }
+        match import_cache.get(import) {
+            Some(expr) => Ok(expr.clone()),
+            None => {
+                // Copy the import stack and push the current import
+                let mut import_stack = import_stack.clone();
+                import_stack.push(import.clone());
+
+                // Resolve the import recursively
+                let expr =
+                    resolve_import(import, &root, import_cache, &import_stack)?;
+
+                // Add the import to the cache
+                import_cache.insert(import.clone(), expr.clone());
+                Ok(expr)
             }
-        };
+        }
+    };
     let expr = expr.traverse_embed(resolve)?;
     Ok(Resolved(expr))
 }
 
 fn skip_resolve_expr(
-    Parsed(expr, _root): Parsed<'_>,
-) -> Result<Resolved<'_>, ImportError> {
-    let resolve =
-        |import: &Import| -> Result<Normalized<'static>, ImportError> {
-            Err(ImportError::UnexpectedImport(import.clone()))
-        };
+    Parsed(expr, _root): Parsed,
+) -> Result<Resolved, ImportError> {
+    let resolve = |import: &Import| -> Result<Normalized, ImportError> {
+        Err(ImportError::UnexpectedImport(import.clone()))
+    };
     let expr = expr.traverse_embed(resolve)?;
     Ok(Resolved(expr))
 }
 
-impl<'a> Parsed<'a> {
-    pub fn parse_file(f: &Path) -> Result<Parsed<'a>, Error> {
+impl Parsed {
+    pub fn parse_file(f: &Path) -> Result<Parsed, Error> {
         let mut buffer = String::new();
         File::open(f)?.read_to_string(&mut buffer)?;
         let expr = parse_expr(&*buffer)?;
@@ -122,14 +116,14 @@ impl<'a> Parsed<'a> {
         Ok(Parsed(expr.unnote().note_absurd(), root))
     }
 
-    pub fn parse_str(s: &'a str) -> Result<Parsed<'a>, Error> {
+    pub fn parse_str(s: &str) -> Result<Parsed, Error> {
         let expr = parse_expr(s)?;
         let root = ImportRoot::LocalDir(std::env::current_dir()?);
         Ok(Parsed(expr, root))
     }
 
     #[allow(dead_code)]
-    pub fn parse_binary_file(f: &Path) -> Result<Parsed<'a>, Error> {
+    pub fn parse_binary_file(f: &Path) -> Result<Parsed, Error> {
         let mut buffer = Vec::new();
         File::open(f)?.read_to_end(&mut buffer)?;
         let expr = crate::binary::decode(&buffer)?;
@@ -137,12 +131,12 @@ impl<'a> Parsed<'a> {
         Ok(Parsed(expr.note_absurd(), root))
     }
 
-    pub fn resolve(self) -> Result<Resolved<'a>, ImportError> {
+    pub fn resolve(self) -> Result<Resolved, ImportError> {
         crate::imports::do_resolve_expr(self, &mut HashMap::new(), &Vec::new())
     }
 
     #[allow(dead_code)]
-    pub fn skip_resolve(self) -> Result<Resolved<'a>, ImportError> {
+    pub fn skip_resolve(self) -> Result<Resolved, ImportError> {
         crate::imports::skip_resolve_expr(self)
     }
 }
diff --git a/dhall/src/normalize.rs b/dhall/src/normalize.rs
index ab9812d..4636859 100644
--- a/dhall/src/normalize.rs
+++ b/dhall/src/normalize.rs
@@ -11,10 +11,10 @@ use dhall_syntax::{
 
 use crate::expr::{Normalized, Type, Typed, TypedInternal};
 
-type InputSubExpr = SubExpr<X, Normalized<'static>>;
+type InputSubExpr = SubExpr<X, Normalized>;
 type OutputSubExpr = SubExpr<X, X>;
 
-impl<'a> Typed<'a> {
+impl Typed {
     /// Reduce an expression to its normal form, performing beta reduction
     ///
     /// `normalize` does not type-check the expression.  You may want to type-check
@@ -24,7 +24,7 @@ impl<'a> Typed<'a> {
     /// However, `normalize` will not fail if the expression is ill-typed and will
     /// leave ill-typed sub-expressions unevaluated.
     ///
-    pub fn normalize(self) -> Normalized<'a> {
+    pub fn normalize(self) -> Normalized {
         let internal = match self.0 {
             TypedInternal::Sort => TypedInternal::Sort,
             TypedInternal::Value(thunk, t) => {
@@ -35,19 +35,15 @@ impl<'a> Typed<'a> {
                 TypedInternal::Value(thunk, t)
             }
         };
-        Normalized(internal, self.1)
+        Normalized(internal)
     }
 
     pub(crate) fn shift(&self, delta: isize, var: &V<Label>) -> Self {
-        Typed(self.0.shift(delta, var), self.1)
+        Typed(self.0.shift(delta, var))
     }
 
-    pub(crate) fn subst_shift(
-        &self,
-        var: &V<Label>,
-        val: &Typed<'static>,
-    ) -> Self {
-        Typed(self.0.subst_shift(var, val), self.1)
+    pub(crate) fn subst_shift(&self, var: &V<Label>, val: &Typed) -> Self {
+        Typed(self.0.subst_shift(var, val))
     }
 
     pub(crate) fn to_value(&self) -> Value {
@@ -74,11 +70,7 @@ impl EnvItem {
         }
     }
 
-    pub(crate) fn subst_shift(
-        &self,
-        var: &V<Label>,
-        val: &Typed<'static>,
-    ) -> Self {
+    pub(crate) fn subst_shift(&self, var: &V<Label>, val: &Typed) -> Self {
         match self {
             EnvItem::Thunk(e) => EnvItem::Thunk(e.subst_shift(var, val)),
             EnvItem::Skip(v) if v == var => EnvItem::Thunk(val.to_thunk()),
@@ -133,7 +125,7 @@ impl NormalizationContext {
         NormalizationContext(Rc::new(self.0.map(|_, e| e.shift(delta, var))))
     }
 
-    fn subst_shift(&self, var: &V<Label>, val: &Typed<'static>) -> Self {
+    fn subst_shift(&self, var: &V<Label>, val: &Typed) -> Self {
         NormalizationContext(Rc::new(
             self.0.map(|_, e| e.subst_shift(var, val)),
         ))
@@ -512,11 +504,7 @@ impl Value {
         }
     }
 
-    pub(crate) fn subst_shift(
-        &self,
-        var: &V<Label>,
-        val: &Typed<'static>,
-    ) -> Self {
+    pub(crate) fn subst_shift(&self, var: &V<Label>, val: &Typed) -> Self {
         match self {
             Value::Lam(x, t, e) => Value::Lam(
                 x.clone(),
@@ -724,7 +712,7 @@ mod thunk {
             }
         }
 
-        fn subst_shift(&self, var: &V<Label>, val: &Typed<'static>) -> Self {
+        fn subst_shift(&self, var: &V<Label>, val: &Typed) -> Self {
             match self {
                 ThunkInternal::Unnormalized(ctx, e) => {
                     ThunkInternal::Unnormalized(
@@ -823,11 +811,7 @@ mod thunk {
             self.0.borrow().shift(delta, var).into_thunk()
         }
 
-        pub(crate) fn subst_shift(
-            &self,
-            var: &V<Label>,
-            val: &Typed<'static>,
-        ) -> Self {
+        pub(crate) fn subst_shift(&self, var: &V<Label>, val: &Typed) -> Self {
             self.0.borrow().subst_shift(var, val).into_thunk()
         }
     }
@@ -839,7 +823,7 @@ pub(crate) use thunk::Thunk;
 #[derive(Debug, Clone)]
 pub(crate) enum TypeThunk {
     Thunk(Thunk),
-    Type(Type<'static>),
+    Type(Type),
 }
 
 impl TypeThunk {
@@ -851,7 +835,7 @@ impl TypeThunk {
         TypeThunk::Thunk(th)
     }
 
-    pub(crate) fn from_type(t: Type<'static>) -> TypeThunk {
+    pub(crate) fn from_type(t: Type) -> TypeThunk {
         TypeThunk::Type(t)
     }
 
@@ -880,11 +864,7 @@ impl TypeThunk {
         }
     }
 
-    pub(crate) fn subst_shift(
-        &self,
-        var: &V<Label>,
-        val: &Typed<'static>,
-    ) -> Self {
+    pub(crate) fn subst_shift(&self, var: &V<Label>, val: &Typed) -> Self {
         match self {
             TypeThunk::Thunk(th) => TypeThunk::Thunk(th.subst_shift(var, val)),
             TypeThunk::Type(t) => TypeThunk::Type(t.subst_shift(var, val)),
diff --git a/dhall/src/traits/deserialize.rs b/dhall/src/traits/deserialize.rs
index 99ca5ee..e3ff2d5 100644
--- a/dhall/src/traits/deserialize.rs
+++ b/dhall/src/traits/deserialize.rs
@@ -12,7 +12,7 @@ pub trait Deserialize<'de>: Sized {
     fn from_str(s: &'de str, ty: Option<&Type>) -> Result<Self>;
 }
 
-impl<'de: 'a, 'a> Deserialize<'de> for Parsed<'a> {
+impl<'de> Deserialize<'de> for Parsed {
     /// Simply parses the provided string. Ignores the
     /// provided type.
     fn from_str(s: &'de str, _: Option<&Type>) -> Result<Self> {
@@ -20,7 +20,7 @@ impl<'de: 'a, 'a> Deserialize<'de> for Parsed<'a> {
     }
 }
 
-impl<'de: 'a, 'a> Deserialize<'de> for Resolved<'a> {
+impl<'de> Deserialize<'de> for Resolved {
     /// Parses and resolves the provided string. Ignores the
     /// provided type.
     fn from_str(s: &'de str, ty: Option<&Type>) -> Result<Self> {
@@ -28,7 +28,7 @@ impl<'de: 'a, 'a> Deserialize<'de> for Resolved<'a> {
     }
 }
 
-impl<'de: 'a, 'a> Deserialize<'de> for Typed<'a> {
+impl<'de> Deserialize<'de> for Typed {
     /// Parses, resolves and typechecks the provided string.
     fn from_str(s: &'de str, ty: Option<&Type>) -> Result<Self> {
         let resolved = Resolved::from_str(s, ty)?;
@@ -39,14 +39,14 @@ impl<'de: 'a, 'a> Deserialize<'de> for Typed<'a> {
     }
 }
 
-impl<'de: 'a, 'a> Deserialize<'de> for Normalized<'a> {
+impl<'de> Deserialize<'de> for Normalized {
     /// Parses, resolves, typechecks and normalizes the provided string.
     fn from_str(s: &'de str, ty: Option<&Type>) -> Result<Self> {
         Ok(Typed::from_str(s, ty)?.normalize())
     }
 }
 
-impl<'de: 'a, 'a> Deserialize<'de> for Type<'a> {
+impl<'de> Deserialize<'de> for Type {
     fn from_str(s: &'de str, ty: Option<&Type>) -> Result<Self> {
         Ok(Normalized::from_str(s, ty)?.to_type())
     }
diff --git a/dhall/src/traits/dynamic_type.rs b/dhall/src/traits/dynamic_type.rs
index b8f6f6d..858642e 100644
--- a/dhall/src/traits/dynamic_type.rs
+++ b/dhall/src/traits/dynamic_type.rs
@@ -7,29 +7,29 @@ use dhall_syntax::{Const, ExprF};
 use std::borrow::Cow;
 
 pub trait DynamicType {
-    fn get_type<'a>(&'a self) -> Result<Cow<'a, Type<'static>>, TypeError>;
+    fn get_type<'a>(&'a self) -> Result<Cow<'a, Type>, TypeError>;
 }
 
 impl<T: StaticType> DynamicType for T {
-    fn get_type<'a>(&'a self) -> Result<Cow<'a, Type<'static>>, TypeError> {
+    fn get_type<'a>(&'a self) -> Result<Cow<'a, Type>, TypeError> {
         Ok(Cow::Owned(T::get_static_type()))
     }
 }
 
-impl<'a> DynamicType for Type<'a> {
-    fn get_type(&self) -> Result<Cow<'_, Type<'static>>, TypeError> {
+impl DynamicType for Type {
+    fn get_type(&self) -> Result<Cow<'_, Type>, TypeError> {
         self.get_type()
     }
 }
 
-impl<'a> DynamicType for Normalized<'a> {
-    fn get_type(&self) -> Result<Cow<'_, Type<'static>>, TypeError> {
+impl DynamicType for Normalized {
+    fn get_type(&self) -> Result<Cow<'_, Type>, TypeError> {
         self.0.get_type()
     }
 }
 
-impl<'a> DynamicType for Typed<'a> {
-    fn get_type(&self) -> Result<Cow<'_, Type<'static>>, TypeError> {
+impl DynamicType for Typed {
+    fn get_type(&self) -> Result<Cow<'_, Type>, TypeError> {
         self.0.get_type()
     }
 }
diff --git a/dhall/src/traits/static_type.rs b/dhall/src/traits/static_type.rs
index 1255d1c..f90b8df 100644
--- a/dhall/src/traits/static_type.rs
+++ b/dhall/src/traits/static_type.rs
@@ -11,7 +11,7 @@ use dhall_syntax::*;
 /// For now the only interesting impl is [SimpleType] itself, who
 /// has a statically-known type which is not itself a [SimpleType].
 pub trait StaticType {
-    fn get_static_type() -> Type<'static>;
+    fn get_static_type() -> Type;
 }
 
 /// A Rust type that can be represented as a Dhall type.
@@ -29,15 +29,15 @@ pub trait StaticType {
 /// The `Simple` in `SimpleStaticType` indicates that the returned type is
 /// a [SimpleType].
 pub trait SimpleStaticType {
-    fn get_simple_static_type<'a>() -> SimpleType<'a>;
+    fn get_simple_static_type() -> SimpleType;
 }
 
-fn mktype<'a>(x: SubExpr<X, X>) -> SimpleType<'a> {
+fn mktype(x: SubExpr<X, X>) -> SimpleType {
     x.into()
 }
 
 impl<T: SimpleStaticType> StaticType for T {
-    fn get_static_type() -> Type<'static> {
+    fn get_static_type() -> Type {
         crate::expr::Normalized::from_thunk_and_type(
             crate::normalize::Thunk::from_normalized_expr(
                 T::get_simple_static_type().into(),
@@ -48,64 +48,64 @@ impl<T: SimpleStaticType> StaticType for T {
     }
 }
 
-impl<'a> StaticType for SimpleType<'a> {
+impl StaticType for SimpleType {
     /// By definition, a [SimpleType] has type `Type`.
     /// This returns the Dhall expression `Type`
-    fn get_static_type() -> Type<'static> {
+    fn get_static_type() -> Type {
         Type::const_type()
     }
 }
 
 impl SimpleStaticType for bool {
-    fn get_simple_static_type<'a>() -> SimpleType<'a> {
+    fn get_simple_static_type() -> SimpleType {
         mktype(dhall::subexpr!(Bool))
     }
 }
 
 impl SimpleStaticType for Natural {
-    fn get_simple_static_type<'a>() -> SimpleType<'a> {
+    fn get_simple_static_type() -> SimpleType {
         mktype(dhall::subexpr!(Natural))
     }
 }
 
 impl SimpleStaticType for u32 {
-    fn get_simple_static_type<'a>() -> SimpleType<'a> {
+    fn get_simple_static_type() -> SimpleType {
         mktype(dhall::subexpr!(Natural))
     }
 }
 
 impl SimpleStaticType for u64 {
-    fn get_simple_static_type<'a>() -> SimpleType<'a> {
+    fn get_simple_static_type() -> SimpleType {
         mktype(dhall::subexpr!(Natural))
     }
 }
 
 impl SimpleStaticType for Integer {
-    fn get_simple_static_type<'a>() -> SimpleType<'a> {
+    fn get_simple_static_type() -> SimpleType {
         mktype(dhall::subexpr!(Integer))
     }
 }
 
 impl SimpleStaticType for i32 {
-    fn get_simple_static_type<'a>() -> SimpleType<'a> {
+    fn get_simple_static_type() -> SimpleType {
         mktype(dhall::subexpr!(Integer))
     }
 }
 
 impl SimpleStaticType for i64 {
-    fn get_simple_static_type<'a>() -> SimpleType<'a> {
+    fn get_simple_static_type() -> SimpleType {
         mktype(dhall::subexpr!(Integer))
     }
 }
 
 impl SimpleStaticType for String {
-    fn get_simple_static_type<'a>() -> SimpleType<'a> {
+    fn get_simple_static_type() -> SimpleType {
         mktype(dhall::subexpr!(Text))
     }
 }
 
 impl<A: SimpleStaticType, B: SimpleStaticType> SimpleStaticType for (A, B) {
-    fn get_simple_static_type<'a>() -> SimpleType<'a> {
+    fn get_simple_static_type() -> SimpleType {
         let ta: SubExpr<_, _> = A::get_simple_static_type().into();
         let tb: SubExpr<_, _> = B::get_simple_static_type().into();
         mktype(dhall::subexpr!({ _1: ta, _2: tb }))
@@ -113,27 +113,27 @@ impl<A: SimpleStaticType, B: SimpleStaticType> SimpleStaticType for (A, B) {
 }
 
 impl<T: SimpleStaticType> SimpleStaticType for Option<T> {
-    fn get_simple_static_type<'a>() -> SimpleType<'a> {
+    fn get_simple_static_type() -> SimpleType {
         let t: SubExpr<_, _> = T::get_simple_static_type().into();
         mktype(dhall::subexpr!(Optional t))
     }
 }
 
 impl<T: SimpleStaticType> SimpleStaticType for Vec<T> {
-    fn get_simple_static_type<'a>() -> SimpleType<'a> {
+    fn get_simple_static_type() -> SimpleType {
         let t: SubExpr<_, _> = T::get_simple_static_type().into();
         mktype(dhall::subexpr!(List t))
     }
 }
 
 impl<'a, T: SimpleStaticType> SimpleStaticType for &'a T {
-    fn get_simple_static_type<'b>() -> SimpleType<'b> {
+    fn get_simple_static_type() -> SimpleType {
         T::get_simple_static_type()
     }
 }
 
 impl<T> SimpleStaticType for std::marker::PhantomData<T> {
-    fn get_simple_static_type<'a>() -> SimpleType<'a> {
+    fn get_simple_static_type() -> SimpleType {
         mktype(dhall::subexpr!({}))
     }
 }
@@ -141,7 +141,7 @@ impl<T> SimpleStaticType for std::marker::PhantomData<T> {
 impl<T: SimpleStaticType, E: SimpleStaticType> SimpleStaticType
     for std::result::Result<T, E>
 {
-    fn get_simple_static_type<'a>() -> SimpleType<'a> {
+    fn get_simple_static_type() -> SimpleType {
         let tt: SubExpr<_, _> = T::get_simple_static_type().into();
         let te: SubExpr<_, _> = E::get_simple_static_type().into();
         mktype(dhall::subexpr!(< Ok: tt | Err: te>))
diff --git a/dhall/src/typecheck.rs b/dhall/src/typecheck.rs
index 69491c8..74de59b 100644
--- a/dhall/src/typecheck.rs
+++ b/dhall/src/typecheck.rs
@@ -14,21 +14,18 @@ use dhall_syntax::*;
 
 use self::TypeMessage::*;
 
-impl<'a> Resolved<'a> {
-    pub fn typecheck(self) -> Result<Typed<'static>, TypeError> {
+impl Resolved {
+    pub fn typecheck(self) -> Result<Typed, TypeError> {
         type_of(self.0.unnote())
     }
-    pub fn typecheck_with(
-        self,
-        ty: &Type,
-    ) -> Result<Typed<'static>, TypeError> {
+    pub fn typecheck_with(self, ty: &Type) -> Result<Typed, TypeError> {
         let expr: SubExpr<_, _> = self.0.unnote();
         let ty: SubExpr<_, _> = ty.to_expr().embed_absurd();
         type_of(rc(ExprF::Annot(expr, ty)))
     }
     /// Pretends this expression has been typechecked. Use with care.
     #[allow(dead_code)]
-    pub fn skip_typecheck(self) -> Typed<'a> {
+    pub fn skip_typecheck(self) -> Typed {
         Typed::from_thunk_untyped(Thunk::new(
             NormalizationContext::new(),
             self.0.unnote(),
@@ -36,8 +33,8 @@ impl<'a> Resolved<'a> {
     }
 }
 
-impl<'a> Typed<'a> {
-    fn to_type(&self) -> Type<'a> {
+impl Typed {
+    fn to_type(&self) -> Type {
         match &self.to_value() {
             Value::Const(c) => Type(TypeInternal::Const(*c)),
             _ => Type(TypeInternal::Typed(Box::new(self.clone()))),
@@ -45,17 +42,17 @@ impl<'a> Typed<'a> {
     }
 }
 
-impl<'a> Normalized<'a> {
+impl Normalized {
     fn shift(&self, delta: isize, var: &V<Label>) -> Self {
-        Normalized(self.0.shift(delta, var), self.1)
+        Normalized(self.0.shift(delta, var))
     }
-    pub(crate) fn to_type(self) -> Type<'a> {
+    pub(crate) fn to_type(self) -> Type {
         self.0.to_type()
     }
 }
 
-impl<'a> Type<'a> {
-    pub(crate) fn to_normalized(&self) -> Normalized<'a> {
+impl Type {
+    pub(crate) fn to_normalized(&self) -> Normalized {
         self.0.to_normalized()
     }
     pub(crate) fn to_expr(&self) -> SubExpr<X, X> {
@@ -64,13 +61,13 @@ impl<'a> Type<'a> {
     pub(crate) fn to_value(&self) -> Value {
         self.0.to_value()
     }
-    pub(crate) fn get_type(&self) -> Result<Cow<'_, Type<'static>>, TypeError> {
+    pub(crate) fn get_type(&self) -> Result<Cow<'_, Type>, TypeError> {
         self.0.get_type()
     }
     fn as_const(&self) -> Option<Const> {
         self.0.as_const()
     }
-    fn internal(&self) -> &TypeInternal<'a> {
+    fn internal(&self) -> &TypeInternal {
         &self.0
     }
     fn internal_whnf(&self) -> Option<Value> {
@@ -79,11 +76,7 @@ impl<'a> Type<'a> {
     pub(crate) fn shift(&self, delta: isize, var: &V<Label>) -> Self {
         Type(self.0.shift(delta, var))
     }
-    pub(crate) fn subst_shift(
-        &self,
-        var: &V<Label>,
-        val: &Typed<'static>,
-    ) -> Self {
+    pub(crate) fn subst_shift(&self, var: &V<Label>, val: &Typed) -> Self {
         Type(self.0.subst_shift(var, val))
     }
 
@@ -99,10 +92,7 @@ impl<'a> Type<'a> {
 }
 
 impl TypeThunk {
-    fn to_type(
-        &self,
-        ctx: &TypecheckContext,
-    ) -> Result<Type<'static>, TypeError> {
+    fn to_type(&self, ctx: &TypecheckContext) -> Result<Type, TypeError> {
         match self {
             TypeThunk::Type(t) => Ok(t.clone()),
             TypeThunk::Thunk(th) => {
@@ -118,20 +108,20 @@ impl TypeThunk {
 /// The rule is the following: we must _not_ construct values of type `Expr` while typechecking,
 /// but only construct `TypeInternal`s.
 #[derive(Debug, Clone)]
-pub(crate) enum TypeInternal<'a> {
+pub(crate) enum TypeInternal {
     Const(Const),
     /// This must not contain a Const value.
-    Typed(Box<Typed<'a>>),
+    Typed(Box<Typed>),
 }
 
-impl<'a> TypeInternal<'a> {
-    fn to_typed(&self) -> Typed<'a> {
+impl TypeInternal {
+    fn to_typed(&self) -> Typed {
         match self {
             TypeInternal::Typed(e) => e.as_ref().clone(),
             TypeInternal::Const(c) => const_to_typed(*c),
         }
     }
-    fn to_normalized(&self) -> Normalized<'a> {
+    fn to_normalized(&self) -> Normalized {
         self.to_typed().normalize()
     }
     fn to_expr(&self) -> SubExpr<X, X> {
@@ -140,7 +130,7 @@ impl<'a> TypeInternal<'a> {
     fn to_value(&self) -> Value {
         self.to_typed().to_value()
     }
-    pub(crate) fn get_type(&self) -> Result<Cow<'_, Type<'static>>, TypeError> {
+    pub(crate) fn get_type(&self) -> Result<Cow<'_, Type>, TypeError> {
         Ok(match self {
             TypeInternal::Typed(e) => e.get_type()?,
             TypeInternal::Const(c) => Cow::Owned(type_of_const(*c)?),
@@ -165,7 +155,7 @@ impl<'a> TypeInternal<'a> {
             Const(c) => Const(*c),
         }
     }
-    fn subst_shift(&self, var: &V<Label>, val: &Typed<'static>) -> Self {
+    fn subst_shift(&self, var: &V<Label>, val: &Typed) -> Self {
         use TypeInternal::*;
         match self {
             Typed(e) => Typed(Box::new(e.subst_shift(var, val))),
@@ -174,8 +164,8 @@ impl<'a> TypeInternal<'a> {
     }
 }
 
-impl<'a> Eq for TypeInternal<'a> {}
-impl<'a> PartialEq for TypeInternal<'a> {
+impl Eq for TypeInternal {}
+impl PartialEq for TypeInternal {
     fn eq(&self, other: &Self) -> bool {
         self.to_normalized() == other.to_normalized()
     }
@@ -183,8 +173,8 @@ impl<'a> PartialEq for TypeInternal<'a> {
 
 #[derive(Debug, Clone)]
 pub(crate) enum EnvItem {
-    Type(V<Label>, Type<'static>),
-    Value(Normalized<'static>),
+    Type(V<Label>, Type),
+    Value(Normalized),
 }
 
 impl EnvItem {
@@ -204,7 +194,7 @@ impl TypecheckContext {
     pub(crate) fn new() -> Self {
         TypecheckContext(Context::new())
     }
-    pub(crate) fn insert_type(&self, x: &Label, t: Type<'static>) -> Self {
+    pub(crate) fn insert_type(&self, x: &Label, t: Type) -> Self {
         TypecheckContext(
             self.0.map(|_, e| e.shift(1, &x.into())).insert(
                 x.clone(),
@@ -212,17 +202,10 @@ impl TypecheckContext {
             ),
         )
     }
-    pub(crate) fn insert_value(
-        &self,
-        x: &Label,
-        t: Normalized<'static>,
-    ) -> Self {
+    pub(crate) fn insert_value(&self, x: &Label, t: Normalized) -> Self {
         TypecheckContext(self.0.insert(x.clone(), EnvItem::Value(t)))
     }
-    pub(crate) fn lookup(
-        &self,
-        var: &V<Label>,
-    ) -> Option<Cow<'_, Type<'static>>> {
+    pub(crate) fn lookup(&self, var: &V<Label>) -> Option<Cow<'_, Type>> {
         let V(x, n) = var;
         match self.0.lookup(x, *n) {
             Some(EnvItem::Type(_, t)) => Some(Cow::Borrowed(&t)),
@@ -276,8 +259,8 @@ fn match_vars(vl: &V<Label>, vr: &V<Label>, ctx: &[(&Label, &Label)]) -> bool {
 // Equality up to alpha-equivalence (renaming of bound variables)
 fn prop_equal<T, U>(eL0: T, eR0: U) -> bool
 where
-    T: Borrow<Type<'static>>,
-    U: Borrow<Type<'static>>,
+    T: Borrow<Type>,
+    U: Borrow<Type>,
 {
     use dhall_syntax::ExprF::*;
     fn go<'a, S, T>(
@@ -340,7 +323,7 @@ where
     }
 }
 
-fn const_to_typed<'a>(c: Const) -> Typed<'a> {
+fn const_to_typed(c: Const) -> Typed {
     match c {
         Const::Sort => Typed::const_sort(),
         _ => Typed::from_thunk_and_type(
@@ -350,11 +333,11 @@ fn const_to_typed<'a>(c: Const) -> Typed<'a> {
     }
 }
 
-fn const_to_type<'a>(c: Const) -> Type<'a> {
+fn const_to_type(c: Const) -> Type {
     Type(TypeInternal::Const(c))
 }
 
-fn type_of_const<'a>(c: Const) -> Result<Type<'a>, TypeError> {
+fn type_of_const(c: Const) -> Result<Type, TypeError> {
     match c {
         Const::Type => Ok(Type::const_kind()),
         Const::Kind => Ok(Type::const_sort()),
@@ -472,15 +455,15 @@ macro_rules! ensure_simple_type {
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub(crate) enum TypeIntermediate {
-    Pi(TypecheckContext, Label, Type<'static>, Type<'static>),
-    RecordType(TypecheckContext, BTreeMap<Label, Type<'static>>),
-    UnionType(TypecheckContext, BTreeMap<Label, Option<Type<'static>>>),
-    ListType(TypecheckContext, Type<'static>),
-    OptionalType(TypecheckContext, Type<'static>),
+    Pi(TypecheckContext, Label, Type, Type),
+    RecordType(TypecheckContext, BTreeMap<Label, Type>),
+    UnionType(TypecheckContext, BTreeMap<Label, Option<Type>>),
+    ListType(TypecheckContext, Type),
+    OptionalType(TypecheckContext, Type),
 }
 
 impl TypeIntermediate {
-    fn typecheck(self) -> Result<Typed<'static>, TypeError> {
+    fn typecheck(self) -> Result<Typed, TypeError> {
         let mkerr = |ctx, msg| TypeError::new(ctx, msg);
         Ok(match &self {
             TypeIntermediate::Pi(ctx, x, ta, tb) => {
@@ -638,32 +621,32 @@ impl TypeIntermediate {
 /// and turn it into a type, typechecking it along the way.
 fn mktype(
     ctx: &TypecheckContext,
-    e: SubExpr<X, Normalized<'static>>,
-) -> Result<Type<'static>, TypeError> {
+    e: SubExpr<X, Normalized>,
+) -> Result<Type, TypeError> {
     Ok(type_with(ctx, e)?.to_type())
 }
 
-fn builtin_to_type<'a>(b: Builtin) -> Result<Type<'a>, TypeError> {
+fn builtin_to_type(b: Builtin) -> Result<Type, TypeError> {
     mktype(&TypecheckContext::new(), rc(ExprF::Builtin(b)))
 }
 
 /// Intermediary return type
 enum Ret {
     /// Returns the contained value as is
-    RetTyped(Typed<'static>),
+    RetTyped(Typed),
     /// Use the contained Type as the type of the input expression
-    RetType(Type<'static>),
+    RetType(Type),
     /// Returns an expression that must be typechecked and
     /// turned into a Type first.
-    RetExpr(Expr<X, Normalized<'static>>),
+    RetExpr(Expr<X, Normalized>),
 }
 
 /// Type-check an expression and return the expression alongside its type if type-checking
 /// succeeded, or an error if type-checking failed
 fn type_with(
     ctx: &TypecheckContext,
-    e: SubExpr<X, Normalized<'static>>,
-) -> Result<Typed<'static>, TypeError> {
+    e: SubExpr<X, Normalized>,
+) -> Result<Typed, TypeError> {
     use dhall_syntax::ExprF::*;
 
     use Ret::*;
@@ -736,12 +719,12 @@ fn type_with(
 /// layer.
 fn type_last_layer(
     ctx: &TypecheckContext,
-    e: ExprF<Typed<'static>, Label, X, Normalized<'static>>,
+    e: ExprF<Typed, Label, X, Normalized>,
 ) -> Result<Ret, TypeError> {
     use dhall_syntax::BinOp::*;
     use dhall_syntax::Builtin::*;
     use dhall_syntax::ExprF::*;
-    let mkerr = |msg: TypeMessage<'static>| TypeError::new(ctx, msg);
+    let mkerr = |msg: TypeMessage| TypeError::new(ctx, msg);
 
     use Ret::*;
     match e {
@@ -1011,9 +994,7 @@ fn type_last_layer(
 /// `typeOf` is the same as `type_with` with an empty context, meaning that the
 /// expression must be closed (i.e. no free variables), otherwise type-checking
 /// will fail.
-fn type_of(
-    e: SubExpr<X, Normalized<'static>>,
-) -> Result<Typed<'static>, TypeError> {
+fn type_of(e: SubExpr<X, Normalized>) -> Result<Typed, TypeError> {
     let ctx = TypecheckContext::new();
     let e = type_with(&ctx, e)?;
     // Ensure `e` has a type (i.e. `e` is not `Sort`)
@@ -1023,27 +1004,27 @@ fn type_of(
 
 /// The specific type error
 #[derive(Debug)]
-pub(crate) enum TypeMessage<'a> {
+pub(crate) enum TypeMessage {
     UnboundVariable(V<Label>),
-    InvalidInputType(Normalized<'a>),
-    InvalidOutputType(Normalized<'a>),
-    NotAFunction(Typed<'a>),
-    TypeMismatch(Typed<'a>, Normalized<'a>, Typed<'a>),
-    AnnotMismatch(Typed<'a>, Normalized<'a>),
+    InvalidInputType(Normalized),
+    InvalidOutputType(Normalized),
+    NotAFunction(Typed),
+    TypeMismatch(Typed, Normalized, Typed),
+    AnnotMismatch(Typed, Normalized),
     Untyped,
-    InvalidListElement(usize, Normalized<'a>, Typed<'a>),
-    InvalidListType(Normalized<'a>),
-    InvalidOptionalType(Normalized<'a>),
-    InvalidPredicate(Typed<'a>),
-    IfBranchMismatch(Typed<'a>, Typed<'a>),
-    IfBranchMustBeTerm(bool, Typed<'a>),
-    InvalidFieldType(Label, Type<'a>),
-    NotARecord(Label, Normalized<'a>),
-    MissingRecordField(Label, Typed<'a>),
-    MissingUnionField(Label, Normalized<'a>),
-    BinOpTypeMismatch(BinOp, Typed<'a>),
-    NoDependentTypes(Normalized<'a>, Normalized<'a>),
-    InvalidTextInterpolation(Typed<'a>),
+    InvalidListElement(usize, Normalized, Typed),
+    InvalidListType(Normalized),
+    InvalidOptionalType(Normalized),
+    InvalidPredicate(Typed),
+    IfBranchMismatch(Typed, Typed),
+    IfBranchMustBeTerm(bool, Typed),
+    InvalidFieldType(Label, Type),
+    NotARecord(Label, Normalized),
+    MissingRecordField(Label, Typed),
+    MissingUnionField(Label, Normalized),
+    BinOpTypeMismatch(BinOp, Typed),
+    NoDependentTypes(Normalized, Normalized),
+    InvalidTextInterpolation(Typed),
     Sort,
     Unimplemented,
 }
@@ -1051,14 +1032,14 @@ pub(crate) enum TypeMessage<'a> {
 /// A structured type error that includes context
 #[derive(Debug)]
 pub struct TypeError {
-    type_message: TypeMessage<'static>,
+    type_message: TypeMessage,
     context: TypecheckContext,
 }
 
 impl TypeError {
     pub(crate) fn new(
         context: &TypecheckContext,
-        type_message: TypeMessage<'static>,
+        type_message: TypeMessage,
     ) -> Self {
         TypeError {
             context: context.clone(),
@@ -1073,7 +1054,7 @@ impl From<TypeError> for std::option::NoneError {
     }
 }
 
-impl ::std::error::Error for TypeMessage<'static> {
+impl ::std::error::Error for TypeMessage {
     fn description(&self) -> &str {
         match *self {
             // UnboundVariable => "Unbound variable",
@@ -1086,7 +1067,7 @@ impl ::std::error::Error for TypeMessage<'static> {
     }
 }
 
-impl fmt::Display for TypeMessage<'static> {
+impl fmt::Display for TypeMessage {
     fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
         match self {
             // UnboundVariable(_) => {
diff --git a/dhall/tests/traits.rs b/dhall/tests/traits.rs
index 15db2a5..6604c06 100644
--- a/dhall/tests/traits.rs
+++ b/dhall/tests/traits.rs
@@ -5,7 +5,7 @@ use dhall_syntax::{SubExpr, X};
 
 #[test]
 fn test_static_type() {
-    fn mktype(x: SubExpr<X, X>) -> dhall::expr::SimpleType<'static> {
+    fn mktype(x: SubExpr<X, X>) -> dhall::expr::SimpleType {
         x.into()
     }
 
diff --git a/dhall_proc_macros/src/derive.rs b/dhall_proc_macros/src/derive.rs
index bcefb17..1ccb28b 100644
--- a/dhall_proc_macros/src/derive.rs
+++ b/dhall_proc_macros/src/derive.rs
@@ -168,8 +168,8 @@ pub fn derive_simple_static_type_inner(
         impl #impl_generics ::dhall::de::SimpleStaticType
                 for #ident #ty_generics
                 #where_clause {
-            fn get_simple_static_type<'get_simple_static_type>() ->
-                    ::dhall::expr::SimpleType<'get_simple_static_type> {
+            fn get_simple_static_type() ->
+                    ::dhall::expr::SimpleType {
                 #(#assertions)*
                 ::dhall::expr::SimpleType::from(#get_type)
             }
diff --git a/dhall_syntax/src/parser.rs b/dhall_syntax/src/parser.rs
index b8a7002..38e67a8 100644
--- a/dhall_syntax/src/parser.rs
+++ b/dhall_syntax/src/parser.rs
@@ -16,22 +16,21 @@ use crate::*;
 // their own crate because they are quite general and useful. For now they
 // are here and hopefully you can figure out how they work.
 
-type ParsedExpr<'a> = Expr<Span<'a>, Import>;
-type ParsedSubExpr<'a> = SubExpr<Span<'a>, Import>;
-type ParsedText<'a> = InterpolatedText<SubExpr<Span<'a>, Import>>;
-type ParsedTextContents<'a> =
-    InterpolatedTextContents<SubExpr<Span<'a>, Import>>;
+type ParsedExpr = Expr<Span, Import>;
+type ParsedSubExpr = SubExpr<Span, Import>;
+type ParsedText = InterpolatedText<SubExpr<Span, Import>>;
+type ParsedTextContents = InterpolatedTextContents<SubExpr<Span, Import>>;
 
 pub type ParseError = pest::error::Error<Rule>;
 
 pub type ParseResult<T> = Result<T, ParseError>;
 
-fn rc(x: ParsedExpr<'_>) -> ParsedSubExpr<'_> {
+fn rc(x: ParsedExpr) -> ParsedSubExpr {
     crate::rc(x)
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
-pub struct Span<'a> {
+pub struct Span {
     input: Rc<str>,
     /// # Safety
     ///
@@ -41,21 +40,19 @@ pub struct Span<'a> {
     ///
     /// Must be a valid character boundary index into `input`.
     end: usize,
-    phantom: std::marker::PhantomData<&'a ()>,
 }
 
-impl<'a> Span<'a> {
+impl Span {
     fn make(input: Rc<str>, sp: pest::Span) -> Self {
         Span {
             input,
             start: sp.start(),
             end: sp.end(),
-            phantom: std::marker::PhantomData,
         }
     }
 }
 
-fn spanned<'a>(_span: Span<'a>, x: ParsedExpr<'a>) -> ParsedExpr<'a> {
+fn spanned(_span: Span, x: ParsedExpr) -> ParsedExpr {
     x
     // This breaks equality testing; I need to fix that first
     // Note(span, rc(x))
@@ -338,13 +335,13 @@ make_parser! {
         [quoted_label(l)] => l,
     ));
 
-    rule!(double_quote_literal<ParsedText<'a>>; children!(
+    rule!(double_quote_literal<ParsedText>; children!(
         [double_quote_chunk(chunks)..] => {
             chunks.collect()
         }
     ));
 
-    rule!(double_quote_chunk<ParsedTextContents<'a>>; children!(
+    rule!(double_quote_chunk<ParsedTextContents>; children!(
         [interpolation(e)] => {
             InterpolatedTextContents::Expr(rc(e))
         },
@@ -381,7 +378,7 @@ make_parser! {
         captured_str!(s) => s
     );
 
-    rule!(single_quote_literal<ParsedText<'a>>; children!(
+    rule!(single_quote_literal<ParsedText>; children!(
         [single_quote_continue(lines)] => {
             let space = InterpolatedTextContents::Text(" ".to_owned());
             let newline = InterpolatedTextContents::Text("\n".to_owned());
@@ -411,11 +408,11 @@ make_parser! {
     rule!(escaped_interpolation<&'a str>;
         captured_str!(_) => "${"
     );
-    rule!(interpolation<ParsedExpr<'a>>; children!(
+    rule!(interpolation<ParsedExpr>; children!(
         [expression(e)] => e
     ));
 
-    rule!(single_quote_continue<Vec<Vec<ParsedTextContents<'a>>>>; children!(
+    rule!(single_quote_continue<Vec<Vec<ParsedTextContents>>>; children!(
         [interpolation(c), single_quote_continue(lines)] => {
             let c = InterpolatedTextContents::Expr(rc(c));
             let mut lines = lines;
@@ -450,7 +447,7 @@ make_parser! {
         },
     ));
 
-    rule!(builtin<ParsedExpr<'a>>; span;
+    rule!(builtin<ParsedExpr>; span;
         captured_str!(s) => {
             spanned(span, match crate::Builtin::parse(s) {
                 Some(b) => Builtin(b),
@@ -507,7 +504,7 @@ make_parser! {
         }
     );
 
-    rule!(identifier<ParsedExpr<'a>> as expression; span; children!(
+    rule!(identifier<ParsedExpr> as expression; span; children!(
         [variable(v)] => {
             spanned(span, Var(v))
         },
@@ -647,7 +644,7 @@ make_parser! {
 
     token_rule!(Text<()>);
 
-    rule!(import<ParsedExpr<'a>> as expression; span; children!(
+    rule!(import<ParsedExpr> as expression; span; children!(
         [import_hashed(location_hashed)] => {
             spanned(span, Embed(Import {
                 mode: ImportMode::Code,
@@ -669,7 +666,7 @@ make_parser! {
     token_rule!(if_<()>);
     token_rule!(in_<()>);
 
-    rule!(expression<ParsedExpr<'a>> as expression; span; children!(
+    rule!(expression<ParsedExpr> as expression; span; children!(
         [lambda(()), label(l), expression(typ),
                 arrow(()), expression(body)] => {
             spanned(span, Lam(l, rc(typ), rc(body)))
@@ -696,7 +693,7 @@ make_parser! {
         [expression(e)] => e,
     ));
 
-    rule!(let_binding<(Label, Option<ParsedSubExpr<'a>>, ParsedSubExpr<'a>)>;
+    rule!(let_binding<(Label, Option<ParsedSubExpr>, ParsedSubExpr)>;
             children!(
         [label(name), expression(annot), expression(expr)] =>
             (name, Some(rc(annot)), rc(expr)),
@@ -707,7 +704,7 @@ make_parser! {
     token_rule!(List<()>);
     token_rule!(Optional<()>);
 
-    rule!(empty_collection<ParsedExpr<'a>> as expression; span; children!(
+    rule!(empty_collection<ParsedExpr> as expression; span; children!(
         [List(_), expression(t)] => {
             spanned(span, EmptyListLit(rc(t)))
         },
@@ -716,90 +713,90 @@ make_parser! {
         },
     ));
 
-    rule!(non_empty_optional<ParsedExpr<'a>> as expression; span; children!(
+    rule!(non_empty_optional<ParsedExpr> as expression; span; children!(
         [expression(x), Optional(_), expression(t)] => {
             spanned(span, OldOptionalLit(Some(rc(x)), rc(t)))
         }
     ));
 
-    rule!(import_alt_expression<ParsedExpr<'a>> as expression; children!(
+    rule!(import_alt_expression<ParsedExpr> as expression; children!(
         [expression(e)] => e,
         [expression(first), expression(rest)..] => {
             let o = crate::BinOp::ImportAlt;
             rest.fold(first, |acc, e| BinOp(o, rc(acc), rc(e)))
         },
     ));
-    rule!(or_expression<ParsedExpr<'a>> as expression; children!(
+    rule!(or_expression<ParsedExpr> as expression; children!(
         [expression(e)] => e,
         [expression(first), expression(rest)..] => {
             let o = crate::BinOp::BoolOr;
             rest.fold(first, |acc, e| BinOp(o, rc(acc), rc(e)))
         },
     ));
-    rule!(plus_expression<ParsedExpr<'a>> as expression; children!(
+    rule!(plus_expression<ParsedExpr> as expression; children!(
         [expression(e)] => e,
         [expression(first), expression(rest)..] => {
             let o = crate::BinOp::NaturalPlus;
             rest.fold(first, |acc, e| BinOp(o, rc(acc), rc(e)))
         },
     ));
-    rule!(text_append_expression<ParsedExpr<'a>> as expression; children!(
+    rule!(text_append_expression<ParsedExpr> as expression; children!(
         [expression(e)] => e,
         [expression(first), expression(rest)..] => {
             let o = crate::BinOp::TextAppend;
             rest.fold(first, |acc, e| BinOp(o, rc(acc), rc(e)))
         },
     ));
-    rule!(list_append_expression<ParsedExpr<'a>> as expression; children!(
+    rule!(list_append_expression<ParsedExpr> as expression; children!(
         [expression(e)] => e,
         [expression(first), expression(rest)..] => {
             let o = crate::BinOp::ListAppend;
             rest.fold(first, |acc, e| BinOp(o, rc(acc), rc(e)))
         },
     ));
-    rule!(and_expression<ParsedExpr<'a>> as expression; children!(
+    rule!(and_expression<ParsedExpr> as expression; children!(
         [expression(e)] => e,
         [expression(first), expression(rest)..] => {
             let o = crate::BinOp::BoolAnd;
             rest.fold(first, |acc, e| BinOp(o, rc(acc), rc(e)))
         },
     ));
-    rule!(combine_expression<ParsedExpr<'a>> as expression; children!(
+    rule!(combine_expression<ParsedExpr> as expression; children!(
         [expression(e)] => e,
         [expression(first), expression(rest)..] => {
             let o = crate::BinOp::Combine;
             rest.fold(first, |acc, e| BinOp(o, rc(acc), rc(e)))
         },
     ));
-    rule!(prefer_expression<ParsedExpr<'a>> as expression; children!(
+    rule!(prefer_expression<ParsedExpr> as expression; children!(
         [expression(e)] => e,
         [expression(first), expression(rest)..] => {
             let o = crate::BinOp::Prefer;
             rest.fold(first, |acc, e| BinOp(o, rc(acc), rc(e)))
         },
     ));
-    rule!(combine_types_expression<ParsedExpr<'a>> as expression; children!(
+    rule!(combine_types_expression<ParsedExpr> as expression; children!(
         [expression(e)] => e,
         [expression(first), expression(rest)..] => {
             let o = crate::BinOp::CombineTypes;
             rest.fold(first, |acc, e| BinOp(o, rc(acc), rc(e)))
         },
     ));
-    rule!(times_expression<ParsedExpr<'a>> as expression; children!(
+    rule!(times_expression<ParsedExpr> as expression; children!(
         [expression(e)] => e,
         [expression(first), expression(rest)..] => {
             let o = crate::BinOp::NaturalTimes;
             rest.fold(first, |acc, e| BinOp(o, rc(acc), rc(e)))
         },
     ));
-    rule!(equal_expression<ParsedExpr<'a>> as expression; children!(
+    rule!(equal_expression<ParsedExpr> as expression; children!(
         [expression(e)] => e,
         [expression(first), expression(rest)..] => {
             let o = crate::BinOp::BoolEQ;
             rest.fold(first, |acc, e| BinOp(o, rc(acc), rc(e)))
         },
     ));
-    rule!(not_equal_expression<ParsedExpr<'a>> as expression; children!(
+    rule!(not_equal_expression<ParsedExpr> as expression; children!(
         [expression(e)] => e,
         [expression(first), expression(rest)..] => {
             let o = crate::BinOp::BoolNE;
@@ -807,7 +804,7 @@ make_parser! {
         },
     ));
 
-    rule!(annotated_expression<ParsedExpr<'a>> as expression; span; children!(
+    rule!(annotated_expression<ParsedExpr> as expression; span; children!(
         [expression(e)] => e,
         [expression(e), expression(annot)] => {
             spanned(span, Annot(rc(e), rc(annot)))
@@ -816,14 +813,14 @@ make_parser! {
 
     token_rule!(Some_<()>);
 
-    rule!(application_expression<ParsedExpr<'a>> as expression; children!(
+    rule!(application_expression<ParsedExpr> as expression; children!(
         [expression(e)] => e,
         [expression(first), expression(rest)..] => {
             rest.fold(first, |acc, e| App(rc(acc), rc(e)))
         },
     ));
 
-    rule!(first_application_expression<ParsedExpr<'a>> as expression; span;
+    rule!(first_application_expression<ParsedExpr> as expression; span;
             children!(
         [expression(e)] => e,
         [Some_(()), expression(e)] => {
@@ -834,7 +831,7 @@ make_parser! {
         },
     ));
 
-    rule!(selector_expression<ParsedExpr<'a>> as expression; children!(
+    rule!(selector_expression<ParsedExpr> as expression; children!(
         [expression(e)] => e,
         [expression(first), selector(rest)..] => {
             rest.fold(first, |acc, e| match e {
@@ -853,7 +850,7 @@ make_parser! {
         [label(ls)..] => ls.collect(),
     ));
 
-    rule!(primitive_expression<ParsedExpr<'a>> as expression; span; children!(
+    rule!(primitive_expression<ParsedExpr> as expression; span; children!(
         [double_literal(n)] => spanned(span, DoubleLit(n)),
         [natural_literal(n)] => spanned(span, NaturalLit(n)),
         [integer_literal(n)] => spanned(span, IntegerLit(n)),
@@ -862,15 +859,15 @@ make_parser! {
         [expression(e)] => e,
     ));
 
-    rule!(empty_record_literal<ParsedExpr<'a>> as expression; span;
+    rule!(empty_record_literal<ParsedExpr> as expression; span;
         captured_str!(_) => spanned(span, RecordLit(BTreeMap::new()))
     );
 
-    rule!(empty_record_type<ParsedExpr<'a>> as expression; span;
+    rule!(empty_record_type<ParsedExpr> as expression; span;
         captured_str!(_) => spanned(span, RecordType(BTreeMap::new()))
     );
 
-    rule!(non_empty_record_type_or_literal<ParsedExpr<'a>> as expression; span;
+    rule!(non_empty_record_type_or_literal<ParsedExpr> as expression; span;
           children!(
         [label(first_label), non_empty_record_type(rest)] => {
             let (first_expr, mut map) = rest;
@@ -885,28 +882,28 @@ make_parser! {
     ));
 
     rule!(non_empty_record_type
-          <(ParsedExpr<'a>, BTreeMap<Label, ParsedSubExpr<'a>>)>; children!(
+          <(ParsedExpr, BTreeMap<Label, ParsedSubExpr>)>; children!(
         [expression(expr), record_type_entry(entries)..] => {
             (expr, entries.collect())
         }
     ));
 
-    rule!(record_type_entry<(Label, ParsedSubExpr<'a>)>; children!(
+    rule!(record_type_entry<(Label, ParsedSubExpr)>; children!(
         [label(name), expression(expr)] => (name, rc(expr))
     ));
 
     rule!(non_empty_record_literal
-          <(ParsedExpr<'a>, BTreeMap<Label, ParsedSubExpr<'a>>)>; children!(
+          <(ParsedExpr, BTreeMap<Label, ParsedSubExpr>)>; children!(
         [expression(expr), record_literal_entry(entries)..] => {
             (expr, entries.collect())
         }
     ));
 
-    rule!(record_literal_entry<(Label, ParsedSubExpr<'a>)>; children!(
+    rule!(record_literal_entry<(Label, ParsedSubExpr)>; children!(
         [label(name), expression(expr)] => (name, rc(expr))
     ));
 
-    rule!(union_type_or_literal<ParsedExpr<'a>> as expression; span; children!(
+    rule!(union_type_or_literal<ParsedExpr> as expression; span; children!(
         [empty_union_type(_)] => {
             spanned(span, UnionType(BTreeMap::new()))
         },
@@ -921,8 +918,8 @@ make_parser! {
     token_rule!(empty_union_type<()>);
 
     rule!(non_empty_union_type_or_literal
-          <(Option<(Label, ParsedSubExpr<'a>)>,
-            BTreeMap<Label, Option<ParsedSubExpr<'a>>>)>;
+          <(Option<(Label, ParsedSubExpr)>,
+            BTreeMap<Label, Option<ParsedSubExpr>>)>;
             children!(
         [label(l), union_literal_variant_value((e, entries))] => {
             (Some((l, e)), entries)
@@ -935,23 +932,23 @@ make_parser! {
     ));
 
     rule!(union_literal_variant_value
-          <(ParsedSubExpr<'a>, BTreeMap<Label, Option<ParsedSubExpr<'a>>>)>;
+          <(ParsedSubExpr, BTreeMap<Label, Option<ParsedSubExpr>>)>;
             children!(
         [expression(e), union_type_entry(entries)..] => {
             (rc(e), entries.collect())
         },
     ));
 
-    rule!(union_type_entry<(Label, Option<ParsedSubExpr<'a>>)>; children!(
+    rule!(union_type_entry<(Label, Option<ParsedSubExpr>)>; children!(
         [label(name), expression(expr)] => (name, Some(rc(expr))),
         [label(name)] => (name, None),
     ));
 
     // TODO: unary union variants
     rule!(union_type_or_literal_variant_type
-          <(Option<ParsedSubExpr<'a>>,
-            (Option<(Label, ParsedSubExpr<'a>)>,
-             BTreeMap<Label, Option<ParsedSubExpr<'a>>>))>;
+          <(Option<ParsedSubExpr>,
+            (Option<(Label, ParsedSubExpr)>,
+             BTreeMap<Label, Option<ParsedSubExpr>>))>;
                 children!(
         [expression(e), non_empty_union_type_or_literal(rest)] => {
             (Some(rc(e)), rest)
@@ -967,7 +964,7 @@ make_parser! {
         },
     ));
 
-    rule!(non_empty_list_literal<ParsedExpr<'a>> as expression; span;
+    rule!(non_empty_list_literal<ParsedExpr> as expression; span;
           children!(
         [expression(items)..] => spanned(
             span,
@@ -975,12 +972,12 @@ make_parser! {
         )
     ));
 
-    rule!(final_expression<ParsedExpr<'a>> as expression; children!(
+    rule!(final_expression<ParsedExpr> as expression; children!(
         [expression(e), EOI(_eoi)] => e
     ));
 }
 
-pub fn parse_expr<'a>(s: &'a str) -> ParseResult<ParsedSubExpr<'a>> {
+pub fn parse_expr<'a>(s: &'a str) -> ParseResult<ParsedSubExpr> {
     let mut pairs = DhallParser::parse(Rule::final_expression, s)?;
     let rc_input = s.to_string().into();
     let expr = do_parse(rc_input, pairs.next().unwrap())?;
-- 
cgit v1.2.3