add type substitutions to serde_dhall

this adds subsititutions, which work similar to the
`Dhall.substitutions` mechanism of the Haskell dhall package, and which
can be used e.g. like this:

```rust
serde_dhall.from_str(...)
  .substitute_names(hashmap!["Newtype" => static_type])
  .parse::<SimpleType>()?
```

The idea behind this is to make it easy to add programmer-defined types
which may be used in configs for programs, without forcing the program's
users to re-import the same type definitions each time (or the
programmers to keep the dhall-based definitions in sync with their rust
types, since these are now generated automatically).

Caveats so far:
 - makes some of the code ugly (dhall internals are now used in
   serde_dhall/src/lib.rs, for example)
 - haven't tested error messages so far
 - some unecessary copying of strings and static type values

2 files changed, 18 insertions, 0 deletions

diff --git a/dhall/src/lib.rs b/dhall/src/lib.rs
index 4238b6e..f3a11a1 100644
--- a/dhall/src/lib.rs
+++ b/dhall/src/lib.rs
@@ -99,6 +99,11 @@ impl Parsed {
     pub fn to_expr(&self) -> Expr {
         self.0.clone()
     }
+
+    pub fn substitute_name(self, label: syntax::Label, value: Expr) -> Parsed {
+        let Parsed (expr, import_location) = self;
+        Parsed (expr.substitute_name(label, value), import_location)
+    }
 }
 
 impl<'cx> Resolved<'cx> {
diff --git a/dhall/src/syntax/ast/expr.rs b/dhall/src/syntax/ast/expr.rs
index eba2735..bc3ffa4 100644
--- a/dhall/src/syntax/ast/expr.rs
+++ b/dhall/src/syntax/ast/expr.rs
@@ -182,6 +182,19 @@ impl Expr {
         let data = binary::encode(self)?;
         Ok(crate::utils::sha256_hash(&data))
     }
+
+    /// this wraps the expression into an additional let-binding
+    pub fn substitute_name(self, label: Label, value: Expr) -> Expr {
+        Expr::new(
+            ExprKind::Let(
+                label,
+                None,
+                value,
+                self
+            ),
+            Span::Artificial
+        )
+    }
 }
 
 // Empty enum to indicate that no error can occur