From 4d92f06c98c98c014a02c218b6c31cf81d9f0fec Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Wed, 6 Mar 2019 16:30:40 +0100
Subject: Move context to dhall_core

---
 dhall/src/context.rs      | 56 -----------------------------------------------
 dhall/src/lib.rs          |  1 -
 dhall/src/typecheck.rs    |  2 +-
 dhall_core/src/context.rs | 56 +++++++++++++++++++++++++++++++++++++++++++++++
 dhall_core/src/lib.rs     |  1 +
 5 files changed, 58 insertions(+), 58 deletions(-)
 delete mode 100644 dhall/src/context.rs
 create mode 100644 dhall_core/src/context.rs

diff --git a/dhall/src/context.rs b/dhall/src/context.rs
deleted file mode 100644
index b88a677..0000000
--- a/dhall/src/context.rs
+++ /dev/null
@@ -1,56 +0,0 @@
-use std::collections::HashMap;
-
-/// A `(Context a)` associates `Text` labels with values of type `a`
-///
-/// The `Context` is used for type-checking when `(a = Expr X)`
-///
-/// * You create a `Context` using `empty` and `insert`
-/// * You transform a `Context` using `fmap`
-/// * You consume a `Context` using `lookup` and `toList`
-///
-/// The difference between a `Context` and a `Map` is that a `Context` lets you
-/// have multiple ordered occurrences of the same key and you can query for the
-/// `n`th occurrence of a given key.
-///
-#[derive(Debug, Clone)]
-pub struct Context<'i, T>(HashMap<&'i str, Vec<T>>);
-
-impl<'i, T> Context<'i, T> {
-    /// An empty context with no key-value pairs
-    pub fn new() -> Self {
-        Context(HashMap::new())
-    }
-
-    /// Look up a key by name and index
-    ///
-    /// ```c
-    /// lookup _ _         empty  = Nothing
-    /// lookup k 0 (insert k v c) = Just v
-    /// lookup k n (insert k v c) = lookup k (n - 1) c  -- 1 <= n
-    /// lookup k n (insert j v c) = lookup k  n      c  -- k /= j
-    /// ```
-    pub fn lookup<'a>(&'a self, k: &str, n: usize) -> Option<&'a T> {
-        self.0.get(k).and_then(|v| v.get(v.len() - 1 - n))
-    }
-
-    pub fn map<U, F: Fn(&T) -> U>(&self, f: F) -> Context<'i, U> {
-        Context(
-            self.0
-                .iter()
-                .map(|(k, v)| (*k, v.iter().map(&f).collect()))
-                .collect(),
-        )
-    }
-}
-
-impl<'i, T: Clone> Context<'i, T> {
-    /// Add a key-value pair to the `Context`
-    pub fn insert(&self, k: &'i str, v: T) -> Self {
-        let mut ctx = (*self).clone();
-        {
-            let m = ctx.0.entry(k).or_insert_with(Vec::new);
-            m.push(v);
-        }
-        ctx
-    }
-}
diff --git a/dhall/src/lib.rs b/dhall/src/lib.rs
index 902df53..32662cd 100644
--- a/dhall/src/lib.rs
+++ b/dhall/src/lib.rs
@@ -1,5 +1,4 @@
 #![feature(box_patterns)]
 #![feature(trace_macros)]
 
-pub mod context;
 pub mod typecheck;
diff --git a/dhall/src/typecheck.rs b/dhall/src/typecheck.rs
index 26192d2..aa8aa08 100644
--- a/dhall/src/typecheck.rs
+++ b/dhall/src/typecheck.rs
@@ -3,7 +3,7 @@ use std::collections::BTreeMap;
 use std::collections::HashSet;
 use std::fmt;
 
-use crate::context::Context;
+use dhall_core::context::Context;
 use dhall_core::core;
 use dhall_core::core::Builtin::*;
 use dhall_core::core::Const::*;
diff --git a/dhall_core/src/context.rs b/dhall_core/src/context.rs
new file mode 100644
index 0000000..b88a677
--- /dev/null
+++ b/dhall_core/src/context.rs
@@ -0,0 +1,56 @@
+use std::collections::HashMap;
+
+/// A `(Context a)` associates `Text` labels with values of type `a`
+///
+/// The `Context` is used for type-checking when `(a = Expr X)`
+///
+/// * You create a `Context` using `empty` and `insert`
+/// * You transform a `Context` using `fmap`
+/// * You consume a `Context` using `lookup` and `toList`
+///
+/// The difference between a `Context` and a `Map` is that a `Context` lets you
+/// have multiple ordered occurrences of the same key and you can query for the
+/// `n`th occurrence of a given key.
+///
+#[derive(Debug, Clone)]
+pub struct Context<'i, T>(HashMap<&'i str, Vec<T>>);
+
+impl<'i, T> Context<'i, T> {
+    /// An empty context with no key-value pairs
+    pub fn new() -> Self {
+        Context(HashMap::new())
+    }
+
+    /// Look up a key by name and index
+    ///
+    /// ```c
+    /// lookup _ _         empty  = Nothing
+    /// lookup k 0 (insert k v c) = Just v
+    /// lookup k n (insert k v c) = lookup k (n - 1) c  -- 1 <= n
+    /// lookup k n (insert j v c) = lookup k  n      c  -- k /= j
+    /// ```
+    pub fn lookup<'a>(&'a self, k: &str, n: usize) -> Option<&'a T> {
+        self.0.get(k).and_then(|v| v.get(v.len() - 1 - n))
+    }
+
+    pub fn map<U, F: Fn(&T) -> U>(&self, f: F) -> Context<'i, U> {
+        Context(
+            self.0
+                .iter()
+                .map(|(k, v)| (*k, v.iter().map(&f).collect()))
+                .collect(),
+        )
+    }
+}
+
+impl<'i, T: Clone> Context<'i, T> {
+    /// Add a key-value pair to the `Context`
+    pub fn insert(&self, k: &'i str, v: T) -> Self {
+        let mut ctx = (*self).clone();
+        {
+            let m = ctx.0.entry(k).or_insert_with(Vec::new);
+            m.push(v);
+        }
+        ctx
+    }
+}
diff --git a/dhall_core/src/lib.rs b/dhall_core/src/lib.rs
index e1d0f7d..dbdd08c 100644
--- a/dhall_core/src/lib.rs
+++ b/dhall_core/src/lib.rs
@@ -8,3 +8,4 @@ lalrpop_mod!(pub grammar);
 mod grammar_util;
 pub mod lexer;
 pub mod parser;
+pub mod context;
-- 
cgit v1.2.3