Extract operation-related code to a new module

1 files changed, 2 insertions, 63 deletions

diff --git a/dhall/src/syntax/ast/expr.rs b/dhall/src/syntax/ast/expr.rs
index 51e9ea7..62734bf 100644
--- a/dhall/src/syntax/ast/expr.rs
+++ b/dhall/src/syntax/ast/expr.rs
@@ -1,8 +1,9 @@
 use std::collections::BTreeMap;
 
 use crate::error::Error;
+use crate::operations::OpKind;
 use crate::semantics::Universe;
-use crate::syntax::map::{DupTreeMap, DupTreeSet};
+use crate::syntax::map::DupTreeMap;
 use crate::syntax::visitor;
 use crate::syntax::*;
 
@@ -126,29 +127,6 @@ pub enum NumKind {
     Double(Double),
 }
 
-/// Operations
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub enum OpKind<SubExpr> {
-    ///  `f a`
-    App(SubExpr, SubExpr),
-    /// Binary operations
-    BinOp(BinOp, SubExpr, SubExpr),
-    ///  `if x then y else z`
-    BoolIf(SubExpr, SubExpr, SubExpr),
-    ///  `merge x y : t`
-    Merge(SubExpr, SubExpr, Option<SubExpr>),
-    ///  `toMap x : t`
-    ToMap(SubExpr, Option<SubExpr>),
-    ///  `e.x`
-    Field(SubExpr, Label),
-    ///  `e.{ x, y, z }`
-    Projection(SubExpr, DupTreeSet<Label>),
-    ///  `e.(t)`
-    ProjectionByExpr(SubExpr, SubExpr),
-    ///  `x::y`
-    Completion(SubExpr, SubExpr),
-}
-
 /// Syntax tree for expressions
 // Having the recursion out of the enum definition enables writing
 // much more generic code and improves pattern-matching behind
@@ -249,45 +227,6 @@ impl<SE> ExprKind<SE> {
     }
 }
 
-impl<SE> OpKind<SE> {
-    pub fn traverse_ref<'a, SE2, Err>(
-        &'a self,
-        mut f: impl FnMut(&'a SE) -> Result<SE2, Err>,
-    ) -> Result<OpKind<SE2>, Err> {
-        // Can't use closures because of borrowing rules
-        macro_rules! expr {
-            ($e:expr) => {
-                f($e)?
-            };
-        }
-        macro_rules! opt {
-            ($e:expr) => {
-                $e.as_ref().map(|e| Ok(expr!(e))).transpose()?
-            };
-        }
-
-        use OpKind::*;
-        Ok(match self {
-            App(f, a) => App(expr!(f), expr!(a)),
-            BinOp(o, x, y) => BinOp(*o, expr!(x), expr!(y)),
-            BoolIf(b, t, f) => BoolIf(expr!(b), expr!(t), expr!(f)),
-            Merge(x, y, t) => Merge(expr!(x), expr!(y), opt!(t)),
-            ToMap(x, t) => ToMap(expr!(x), opt!(t)),
-            Field(e, l) => Field(expr!(e), l.clone()),
-            Projection(e, ls) => Projection(expr!(e), ls.clone()),
-            ProjectionByExpr(e, x) => ProjectionByExpr(expr!(e), expr!(x)),
-            Completion(e, x) => Completion(expr!(e), expr!(x)),
-        })
-    }
-
-    pub fn map_ref<'a, SE2>(
-        &'a self,
-        mut f: impl FnMut(&'a SE) -> SE2,
-    ) -> OpKind<SE2> {
-        trivial_result(self.traverse_ref(|x| Ok(f(x))))
-    }
-}
-
 impl Expr {
     pub fn as_ref(&self) -> &UnspannedExpr {
         &self.kind