From 726c281cdd3824fcfdde34fe8d01f95416f7808c Mon Sep 17 00:00:00 2001 From: Nadrieril Date: Tue, 7 May 2019 16:01:24 +0200 Subject: Clean up some of the SubExpr type-changing methods --- dhall/src/core/thunk.rs | 4 +- dhall/src/phase/parse.rs | 2 +- dhall/src/phase/typecheck.rs | 6 +-- dhall_proc_macros/src/quote.rs | 10 ++--- dhall_syntax/src/core.rs | 40 ++++++-------------- dhall_syntax/src/visitor.rs | 84 +++--------------------------------------- 6 files changed, 27 insertions(+), 119 deletions(-) diff --git a/dhall/src/core/thunk.rs b/dhall/src/core/thunk.rs index 8775ce2..69c4347 100644 --- a/dhall/src/core/thunk.rs +++ b/dhall/src/core/thunk.rs @@ -126,7 +126,7 @@ impl Thunk { } pub(crate) fn from_normalized_expr(e: OutputSubExpr) -> Thunk { - Thunk::new(NormalizationContext::new(), e.embed_absurd().note_absurd()) + Thunk::new(NormalizationContext::new(), e.absurd()) } // Normalizes contents to normal form; faster than `normalize_nf` if @@ -253,7 +253,7 @@ impl TypeThunk { TypeThunk::Type(t) => Ok(t.clone()), TypeThunk::Thunk(th) => { // TODO: rule out statically - mktype(ctx, th.normalize_to_expr().embed_absurd().note_absurd()) + mktype(ctx, th.normalize_to_expr().absurd()) } } } diff --git a/dhall/src/phase/parse.rs b/dhall/src/phase/parse.rs index 809faf4..6b426af 100644 --- a/dhall/src/phase/parse.rs +++ b/dhall/src/phase/parse.rs @@ -13,7 +13,7 @@ pub(crate) fn parse_file(f: &Path) -> Result { File::open(f)?.read_to_string(&mut buffer)?; let expr = parse_expr(&*buffer)?; let root = ImportRoot::LocalDir(f.parent().unwrap().to_owned()); - Ok(Parsed(expr.unnote().note_absurd(), root)) + Ok(Parsed(expr, root)) } pub(crate) fn parse_str(s: &str) -> Result { diff --git a/dhall/src/phase/typecheck.rs b/dhall/src/phase/typecheck.rs index 3e6986f..32c1531 100644 --- a/dhall/src/phase/typecheck.rs +++ b/dhall/src/phase/typecheck.rs @@ -230,7 +230,7 @@ pub(crate) fn type_of_const(c: Const) -> Result { } } -fn type_of_builtin(b: Builtin) -> Expr { +fn type_of_builtin(b: Builtin) -> Expr { use dhall_syntax::Builtin::*; match b { Bool | Natural | Integer | Double | Text => dhall::expr!(Type), @@ -635,7 +635,7 @@ fn type_last_layer( } Const(c) => Ok(RetTyped(Typed::from_const(c))), Builtin(b) => { - Ok(RetType(mktype(ctx, rc(type_of_builtin(b)).note_absurd())?)) + Ok(RetType(mktype(ctx, rc(type_of_builtin(b)).absurd())?)) } BoolLit(_) => Ok(RetType(builtin_to_type(Bool)?)), NaturalLit(_) => Ok(RetType(builtin_to_type(Natural)?)), @@ -712,7 +712,7 @@ pub(crate) fn typecheck_with( ty: &Type, ) -> Result { let expr: SubExpr<_, _> = e.0; - let ty: SubExpr<_, _> = ty.to_expr().embed_absurd().note_absurd(); + let ty: SubExpr<_, _> = ty.to_expr().absurd(); type_of(expr.rewrap(ExprF::Annot(expr.clone(), ty))) } pub(crate) fn skip_typecheck(e: Resolved) -> Typed { diff --git a/dhall_proc_macros/src/quote.rs b/dhall_proc_macros/src/quote.rs index eaf4946..77ed5de 100644 --- a/dhall_proc_macros/src/quote.rs +++ b/dhall_proc_macros/src/quote.rs @@ -7,7 +7,7 @@ use std::collections::BTreeMap; pub fn expr(input: proc_macro::TokenStream) -> proc_macro::TokenStream { let input_str = input.to_string(); - let expr: SubExpr<_, Import> = parse_expr(&input_str).unwrap().unnote(); + let expr: SubExpr<_, Import> = parse_expr(&input_str).unwrap(); let no_import = |_: &Import| -> X { panic!("Don't use import in dhall::expr!()") }; let expr = expr.map_embed(no_import); @@ -17,7 +17,7 @@ pub fn expr(input: proc_macro::TokenStream) -> proc_macro::TokenStream { pub fn subexpr(input: proc_macro::TokenStream) -> proc_macro::TokenStream { let input_str = input.to_string(); - let expr: SubExpr<_, Import> = parse_expr(&input_str).unwrap().unnote(); + let expr: SubExpr<_, Import> = parse_expr(&input_str).unwrap(); let no_import = |_: &Import| -> X { panic!("Don't use import in dhall::subexpr!()") }; let expr = expr.map_embed(no_import); @@ -94,8 +94,8 @@ where // Returns an expression of type SubExpr<_, _>. Expects interpolated variables // to be of type SubExpr<_, _>. -fn quote_subexpr( - expr: &SubExpr, +fn quote_subexpr( + expr: &SubExpr, ctx: &Context, ) -> TokenStream { use dhall_syntax::ExprF::*; @@ -131,7 +131,7 @@ fn quote_subexpr( // Returns an expression of type Expr<_, _>. Expects interpolated variables // to be of type SubExpr<_, _>. -fn quote_expr(expr: &Expr, ctx: &Context) -> TokenStream { +fn quote_expr(expr: &Expr, ctx: &Context) -> TokenStream { use dhall_syntax::ExprF::*; match expr.map_ref_with_special_handling_of_binders( |e| quote_subexpr(e, ctx), diff --git a/dhall_syntax/src/core.rs b/dhall_syntax/src/core.rs index 7cdda64..2b76b9a 100644 --- a/dhall_syntax/src/core.rs +++ b/dhall_syntax/src/core.rs @@ -343,15 +343,11 @@ impl Expr { { trivial_result(self.traverse_embed(|x| Ok(map_embed(x)))) } +} - pub fn squash_embed( - &self, - f: impl FnMut(&E) -> SubExpr, - ) -> SubExpr - where - N: Clone, - { - trivial_result(self.visit(&mut visitor::SquashEmbedVisitor(f))) +impl Expr { + pub fn absurd(&self) -> Expr { + self.visit(&mut visitor::AbsurdVisitor) } } @@ -361,12 +357,6 @@ impl Expr { } } -impl Expr { - pub fn embed_absurd(&self) -> Expr { - self.visit(&mut visitor::EmbedAbsurdVisitor) - } -} - impl SubExpr { pub fn as_ref(&self) -> &Expr { &self.0.as_ref().0 @@ -380,17 +370,6 @@ impl SubExpr { SubExpr(Rc::new((x, None))) } - pub fn unnote(&self) -> SubExpr - where - E: Clone, - { - SubExpr::from_expr_no_note( - self.as_ref().visit(&mut visitor::UnNoteVisitor), - ) - } -} - -impl SubExpr { pub fn rewrap(&self, x: Expr) -> SubExpr where N: Clone, @@ -422,7 +401,10 @@ impl SubExpr { &'a self, map_expr: impl FnMut(&'a Self) -> Self, map_under_binder: impl FnMut(&'a Label, &'a Self) -> Self, - ) -> Self { + ) -> Self + where + N: Clone, + { match self.as_ref() { ExprF::Embed(_) => SubExpr::clone(self), // This calls ExprF::map_ref @@ -436,9 +418,9 @@ impl SubExpr { } } -impl SubExpr { - pub fn embed_absurd(&self) -> SubExpr { - self.rewrap(self.as_ref().embed_absurd()) +impl SubExpr { + pub fn absurd(&self) -> SubExpr { + SubExpr::from_expr_no_note(self.as_ref().absurd()) } } diff --git a/dhall_syntax/src/visitor.rs b/dhall_syntax/src/visitor.rs index 7fdf217..20bfc72 100644 --- a/dhall_syntax/src/visitor.rs +++ b/dhall_syntax/src/visitor.rs @@ -421,78 +421,6 @@ where } } -pub struct SquashEmbedVisitor(pub F1); - -impl<'a, 'b, N, E1, E2, F1> - ExprFVeryGenericVisitor<'a, SubExpr, SubExpr, Label, E1> - for &'b mut SquashEmbedVisitor -where - N: Clone + 'a, - F1: FnMut(&E1) -> SubExpr, -{ - type Error = X; - type SE2 = SubExpr; - type L2 = Label; - type E2 = E2; - - fn visit_subexpr( - &mut self, - subexpr: &'a SubExpr, - ) -> Result { - Ok(subexpr.as_ref().visit(&mut **self)?) - } - - fn visit_label( - &mut self, - label: &'a Label, - ) -> Result { - Ok(Label::clone(label)) - } - - fn visit_binder( - mut self, - label: &'a Label, - subexpr: &'a SubExpr, - ) -> Result<(Self::L2, Self::SE2), Self::Error> { - Ok((self.visit_label(label)?, self.visit_subexpr(subexpr)?)) - } - - fn visit_embed_squash( - self, - embed: &'a E1, - ) -> Result, Self::Error> { - Ok((self.0)(embed)) - } - - // Called with the result of the map, in the non-embed case. - // Useful to change the result type, and/or avoid some loss of info - fn visit_resulting_exprf( - result: ExprF, - ) -> Result, Self::Error> { - // TODO: don't lose note - Ok(SubExpr::from_expr_no_note(result)) - } -} - -pub struct UnNoteVisitor; - -impl<'a, 'b, N, E> - ExprFInFallibleVisitor<'a, SubExpr, SubExpr, Label, Label, E, E> - for &'b mut UnNoteVisitor -where - E: Clone + 'a, -{ - fn visit_subexpr(&mut self, subexpr: &'a SubExpr) -> SubExpr { - SubExpr::from_expr_no_note(subexpr.as_ref().visit(&mut **self)) - } - fn visit_embed(self, embed: &'a E) -> E { - E::clone(embed) - } - fn visit_label(&mut self, label: &'a Label) -> Label { - Label::clone(label) - } -} - pub struct NoteAbsurdVisitor; impl<'a, 'b, N, E> @@ -512,16 +440,14 @@ where } } -pub struct EmbedAbsurdVisitor; +pub struct AbsurdVisitor; impl<'a, 'b, N, E> - ExprFInFallibleVisitor<'a, SubExpr, SubExpr, Label, Label, X, E> - for &'b mut EmbedAbsurdVisitor -where - N: Clone + 'a, + ExprFInFallibleVisitor<'a, SubExpr, SubExpr, Label, Label, X, E> + for &'b mut AbsurdVisitor { - fn visit_subexpr(&mut self, subexpr: &'a SubExpr) -> SubExpr { - subexpr.rewrap(subexpr.as_ref().visit(&mut **self)) + fn visit_subexpr(&mut self, subexpr: &'a SubExpr) -> SubExpr { + SubExpr::from_expr_no_note(subexpr.as_ref().visit(&mut **self)) } fn visit_embed(self, embed: &'a X) -> E { match *embed {} -- cgit v1.2.3