diff options
Diffstat (limited to 'dhall_syntax')
-rw-r--r-- | dhall_syntax/src/core.rs | 207 | ||||
-rw-r--r-- | dhall_syntax/src/parser.rs | 24 | ||||
-rw-r--r-- | dhall_syntax/src/printer.rs | 44 | ||||
-rw-r--r-- | dhall_syntax/src/visitor.rs | 130 |
4 files changed, 218 insertions, 187 deletions
diff --git a/dhall_syntax/src/core.rs b/dhall_syntax/src/core.rs index a186d19..c8a2425 100644 --- a/dhall_syntax/src/core.rs +++ b/dhall_syntax/src/core.rs @@ -60,19 +60,7 @@ pub enum Const { /// The `Int` field is a DeBruijn index. /// See dhall-lang/standard/semantics.md for details #[derive(Debug, Clone, PartialEq, Eq)] -pub struct V<Label>(pub Label, pub usize); - -// This is only for the specific `Label` type, not generic -impl From<Label> for V<Label> { - fn from(x: Label) -> V<Label> { - V(x, 0) - } -} -impl<'a> From<&'a Label> for V<Label> { - fn from(x: &'a Label) -> V<Label> { - V(x.clone(), 0) - } -} +pub struct Var<Label>(pub Label, pub usize); // Definition order must match precedence order for // pretty-printing to work correctly @@ -137,44 +125,52 @@ pub enum Builtin { TextShow, } -pub type ParsedExpr = SubExpr<X, Import>; -pub type ResolvedExpr = SubExpr<X, X>; +pub type ParsedExpr = SubExpr<Label, X, Import>; +pub type ResolvedExpr = SubExpr<Label, X, X>; pub type DhallExpr = ResolvedExpr; // Each node carries an annotation. In practice it's either X (no annotation) or a Span. #[derive(Debug)] -pub struct SubExpr<Note, Embed>(Rc<(Expr<Note, Embed>, Option<Note>)>); +pub struct SubExpr<VarLabel, Note, Embed>( + Rc<(Expr<VarLabel, Note, Embed>, Option<Note>)>, +); -impl<Note, Embed: PartialEq> std::cmp::PartialEq for SubExpr<Note, Embed> { +impl<VarLabel: PartialEq, Note, Embed: PartialEq> std::cmp::PartialEq + for SubExpr<VarLabel, Note, Embed> +{ fn eq(&self, other: &Self) -> bool { self.0.as_ref().0 == other.0.as_ref().0 } } -impl<Note, Embed: Eq> std::cmp::Eq for SubExpr<Note, Embed> {} +impl<VarLabel: Eq, Note, Embed: Eq> std::cmp::Eq + for SubExpr<VarLabel, Note, Embed> +{ +} -pub type Expr<Note, Embed> = ExprF<SubExpr<Note, Embed>, Label, Embed>; +pub type Expr<VarLabel, Note, Embed> = + ExprF<SubExpr<VarLabel, Note, Embed>, VarLabel, Embed>; /// Syntax tree for expressions // Having the recursion out of the enum definition enables writing // much more generic code and improves pattern-matching behind // smart pointers. #[derive(Debug, Clone, PartialEq, Eq)] -pub enum ExprF<SubExpr, Label, Embed> { +pub enum ExprF<SubExpr, VarLabel, Embed> { Const(Const), /// `x` /// `x@n` - Var(V<Label>), + Var(Var<VarLabel>), /// `λ(x : A) -> b` - Lam(Label, SubExpr, SubExpr), + Lam(VarLabel, SubExpr, SubExpr), /// `A -> B` /// `∀(x : A) -> B` - Pi(Label, SubExpr, SubExpr), + Pi(VarLabel, SubExpr, SubExpr), /// `f a` App(SubExpr, SubExpr), /// `let x = r in e` /// `let x : t = r in e` - Let(Label, Option<SubExpr>, SubExpr, SubExpr), + Let(VarLabel, Option<SubExpr>, SubExpr, SubExpr), /// `x : t` Annot(SubExpr, SubExpr), /// Built-in values @@ -235,11 +231,7 @@ impl<SE, L, E> ExprF<SE, L, E> { visit_under_binder: impl FnOnce(&'a L, &'a SE) -> Result<SE2, Err>, visit_embed: impl FnOnce(&'a E) -> Result<E2, Err>, visit_label: impl FnMut(&'a L) -> Result<L2, Err>, - ) -> Result<ExprF<SE2, L2, E2>, Err> - where - L: Ord, - L2: Ord, - { + ) -> Result<ExprF<SE2, L2, E2>, Err> { self.visit(visitor::TraverseRefWithBindersVisitor { visit_subexpr, visit_under_binder, @@ -253,11 +245,7 @@ impl<SE, L, E> ExprF<SE, L, E> { visit_subexpr: impl FnMut(&'a SE) -> Result<SE2, Err>, visit_embed: impl FnOnce(&'a E) -> Result<E2, Err>, visit_label: impl FnMut(&'a L) -> Result<L2, Err>, - ) -> Result<ExprF<SE2, L2, E2>, Err> - where - L: Ord, - L2: Ord, - { + ) -> Result<ExprF<SE2, L2, E2>, Err> { self.visit(visitor::TraverseRefVisitor { visit_subexpr, visit_embed, @@ -271,11 +259,7 @@ impl<SE, L, E> ExprF<SE, L, E> { mut map_under_binder: impl FnMut(&'a L, &'a SE) -> SE2, map_embed: impl FnOnce(&'a E) -> E2, mut map_label: impl FnMut(&'a L) -> L2, - ) -> ExprF<SE2, L2, E2> - where - L: Ord, - L2: Ord, - { + ) -> ExprF<SE2, L2, E2> { trivial_result(self.traverse_ref_with_special_handling_of_binders( |x| Ok(map_subexpr(x)), |l, x| Ok(map_under_binder(l, x)), @@ -289,11 +273,7 @@ impl<SE, L, E> ExprF<SE, L, E> { mut map_subexpr: impl FnMut(&'a SE) -> SE2, map_embed: impl FnOnce(&'a E) -> E2, mut map_label: impl FnMut(&'a L) -> L2, - ) -> ExprF<SE2, L2, E2> - where - L: Ord, - L2: Ord, - { + ) -> ExprF<SE2, L2, E2> { trivial_result(self.traverse_ref( |x| Ok(map_subexpr(x)), |x| Ok(map_embed(x)), @@ -306,7 +286,7 @@ impl<SE, L, E> ExprF<SE, L, E> { visit_subexpr: impl FnMut(&'a SE) -> Result<SE2, Err>, ) -> Result<ExprF<SE2, L, E>, Err> where - L: Ord + Clone, + L: Clone, E: Clone, { self.traverse_ref( @@ -321,26 +301,31 @@ impl<SE, L, E> ExprF<SE, L, E> { map_subexpr: impl Fn(&'a SE) -> SE2, ) -> ExprF<SE2, L, E> where - L: Ord + Clone, + L: Clone, E: Clone, { self.map_ref(map_subexpr, E::clone, L::clone) } } -impl<N, E> Expr<N, E> { +impl<L, N, E> Expr<L, N, E> { fn traverse_embed<E2, Err>( &self, visit_embed: impl FnMut(&E) -> Result<E2, Err>, - ) -> Result<Expr<N, E2>, Err> + ) -> Result<Expr<L, N, E2>, Err> where + L: Clone, N: Clone, { self.visit(&mut visitor::TraverseEmbedVisitor(visit_embed)) } - fn map_embed<E2>(&self, mut map_embed: impl FnMut(&E) -> E2) -> Expr<N, E2> + fn map_embed<E2>( + &self, + mut map_embed: impl FnMut(&E) -> E2, + ) -> Expr<L, N, E2> where + L: Clone, N: Clone, { trivial_result(self.traverse_embed(|x| Ok(map_embed(x)))) @@ -348,52 +333,52 @@ impl<N, E> Expr<N, E> { pub fn squash_embed<E2>( &self, - f: impl FnMut(&E) -> SubExpr<N, E2>, - ) -> SubExpr<N, E2> + f: impl FnMut(&E) -> SubExpr<L, N, E2>, + ) -> SubExpr<L, N, E2> where + L: Clone, N: Clone, { trivial_result(self.visit(&mut visitor::SquashEmbedVisitor(f))) } } -impl<E: Clone> Expr<X, E> { - pub fn note_absurd<N>(&self) -> Expr<N, E> { +impl<L: Clone, E: Clone> Expr<L, X, E> { + pub fn note_absurd<N>(&self) -> Expr<L, N, E> { self.visit(&mut visitor::NoteAbsurdVisitor) } } -impl<N: Clone> Expr<N, X> { - pub fn embed_absurd<E>(&self) -> Expr<N, E> { +impl<L: Clone, N: Clone> Expr<L, N, X> { + pub fn embed_absurd<E>(&self) -> Expr<L, N, E> { self.visit(&mut visitor::EmbedAbsurdVisitor) } } -impl<N, E> SubExpr<N, E> { - pub fn as_ref(&self) -> &Expr<N, E> { +impl<V, N, E> SubExpr<V, N, E> { + pub fn as_ref(&self) -> &Expr<V, N, E> { &self.0.as_ref().0 } - pub fn new(x: Expr<N, E>, n: N) -> Self { + pub fn new(x: Expr<V, N, E>, n: N) -> Self { SubExpr(Rc::new((x, Some(n)))) } - pub fn from_expr_no_note(x: Expr<N, E>) -> Self { + pub fn from_expr_no_note(x: Expr<V, N, E>) -> Self { SubExpr(Rc::new((x, None))) } - pub fn unnote(&self) -> SubExpr<X, E> + pub fn unnote(&self) -> SubExpr<V, X, E> where + V: Clone, E: Clone, { SubExpr::from_expr_no_note( self.as_ref().visit(&mut visitor::UnNoteVisitor), ) } -} -impl<N: Clone, E> SubExpr<N, E> { - pub fn rewrap<E2>(&self, x: Expr<N, E2>) -> SubExpr<N, E2> + pub fn rewrap<E2>(&self, x: Expr<V, N, E2>) -> SubExpr<V, N, E2> where N: Clone, { @@ -403,8 +388,9 @@ impl<N: Clone, E> SubExpr<N, E> { pub fn traverse_embed<E2, Err>( &self, visit_embed: impl FnMut(&E) -> Result<E2, Err>, - ) -> Result<SubExpr<N, E2>, Err> + ) -> Result<SubExpr<V, N, E2>, Err> where + V: Clone, N: Clone, { Ok(self.rewrap(self.as_ref().traverse_embed(visit_embed)?)) @@ -413,8 +399,9 @@ impl<N: Clone, E> SubExpr<N, E> { pub fn map_embed<E2>( &self, map_embed: impl FnMut(&E) -> E2, - ) -> SubExpr<N, E2> + ) -> SubExpr<V, N, E2> where + V: Clone, N: Clone, { self.rewrap(self.as_ref().map_embed(map_embed)) @@ -423,8 +410,12 @@ impl<N: Clone, E> SubExpr<N, E> { pub fn map_subexprs_with_special_handling_of_binders<'a>( &'a self, map_expr: impl FnMut(&'a Self) -> Self, - map_under_binder: impl FnMut(&'a Label, &'a Self) -> Self, - ) -> Self { + map_under_binder: impl FnMut(&'a V, &'a Self) -> Self, + ) -> Self + where + V: Clone, + N: Clone, + { match self.as_ref() { ExprF::Embed(_) => SubExpr::clone(self), // This calls ExprF::map_ref @@ -432,7 +423,7 @@ impl<N: Clone, E> SubExpr<N, E> { map_expr, map_under_binder, |_| unreachable!(), - Label::clone, + V::clone, )), } } @@ -441,26 +432,34 @@ impl<N: Clone, E> SubExpr<N, E> { /// capture by shifting variable indices /// See https://github.com/dhall-lang/dhall-lang/blob/master/standard/semantics.md#shift /// for details - pub fn shift(&self, delta: isize, var: &V<Label>) -> Self { + pub fn shift(&self, delta: isize, var: &Var<V>) -> Self + where + V: Clone + PartialEq, + N: Clone, + { match self.as_ref() { ExprF::Var(v) => self.rewrap(ExprF::Var(v.shift(delta, var))), _ => self.map_subexprs_with_special_handling_of_binders( |e| e.shift(delta, var), - |x: &Label, e| e.shift(delta, &var.shift(1, &x.into())), + |x: &V, e| e.shift(delta, &var.shift(1, &Var::new(x.clone()))), ), } } - pub fn subst_shift(&self, var: &V<Label>, val: &Self) -> Self { + pub fn subst_shift(&self, var: &Var<V>, val: &Self) -> Self + where + V: Clone + PartialEq, + N: Clone, + { match self.as_ref() { ExprF::Var(v) if v == var => val.clone(), ExprF::Var(v) => self.rewrap(ExprF::Var(v.shift(-1, var))), _ => self.map_subexprs_with_special_handling_of_binders( |e| e.subst_shift(var, val), - |x: &Label, e| { + |x: &V, e| { e.subst_shift( - &var.shift(1, &x.into()), - &val.shift(1, &x.into()), + &var.shift(1, &Var::new(x.clone())), + &val.shift(1, &Var::new(x.clone())), ) }, ), @@ -468,26 +467,26 @@ impl<N: Clone, E> SubExpr<N, E> { } } -impl<N: Clone> SubExpr<N, X> { - pub fn embed_absurd<T>(&self) -> SubExpr<N, T> { +impl<L: Clone, N: Clone> SubExpr<L, N, X> { + pub fn embed_absurd<T>(&self) -> SubExpr<L, N, T> { self.rewrap(self.as_ref().embed_absurd()) } } -impl<E: Clone> SubExpr<X, E> { - pub fn note_absurd<N>(&self) -> SubExpr<N, E> { +impl<L: Clone, E: Clone> SubExpr<L, X, E> { + pub fn note_absurd<N>(&self) -> SubExpr<L, N, E> { SubExpr::from_expr_no_note(self.as_ref().note_absurd()) } } -impl<N, E> Clone for SubExpr<N, E> { +impl<L, N, E> Clone for SubExpr<L, N, E> { fn clone(&self) -> Self { SubExpr(Rc::clone(&self.0)) } } // Should probably rename this -pub fn rc<E>(x: Expr<X, E>) -> SubExpr<X, E> { +pub fn rc<L, E>(x: Expr<L, X, E>) -> SubExpr<L, X, E> { SubExpr::from_expr_no_note(x) } @@ -501,18 +500,35 @@ fn add_ui(u: usize, i: isize) -> usize { } } -impl<Label: PartialEq + Clone> V<Label> { - pub fn shift(&self, delta: isize, var: &V<Label>) -> Self { - let V(x, n) = var; - let V(y, m) = self; +impl<L> Var<L> { + fn new(x: L) -> Self { + Var(x, 0) + } +} +impl<L: PartialEq + Clone> Var<L> { + pub fn shift(&self, delta: isize, var: &Var<L>) -> Self { + let Var(x, n) = var; + let Var(y, m) = self; if x == y && n <= m { - V(y.clone(), add_ui(*m, delta)) + Var(y.clone(), add_ui(*m, delta)) } else { - V(y.clone(), *m) + Var(y.clone(), *m) } } } +// This is only for the specific `Label` type, not generic +impl From<Label> for Var<Label> { + fn from(x: Label) -> Var<Label> { + Var(x, 0) + } +} +impl<'a> From<&'a Label> for Var<Label> { + fn from(x: &'a Label) -> Var<Label> { + Var(x.clone(), 0) + } +} + /// `shift` is used by both normalization and type-checking to avoid variable /// capture by shifting variable indices /// See https://github.com/dhall-lang/dhall-lang/blob/master/standard/semantics.md#shift @@ -520,9 +536,9 @@ impl<Label: PartialEq + Clone> V<Label> { /// pub fn shift<N, E>( delta: isize, - var: &V<Label>, - in_expr: &SubExpr<N, E>, -) -> SubExpr<N, E> + var: &Var<Label>, + in_expr: &SubExpr<Label, N, E>, +) -> SubExpr<Label, N, E> where N: Clone, { @@ -531,8 +547,8 @@ where pub fn shift0_multiple<N, E>( deltas: &HashMap<Label, isize>, - in_expr: &SubExpr<N, E>, -) -> SubExpr<N, E> + in_expr: &SubExpr<Label, N, E>, +) -> SubExpr<Label, N, E> where N: Clone, { @@ -542,16 +558,15 @@ where fn shift0_multiple_inner<N, E>( ctx: &Context<Label, ()>, deltas: &HashMap<Label, isize>, - in_expr: &SubExpr<N, E>, -) -> SubExpr<N, E> + in_expr: &SubExpr<Label, N, E>, +) -> SubExpr<Label, N, E> where N: Clone, { - use crate::ExprF::*; match in_expr.as_ref() { - Var(V(y, m)) if ctx.lookup(y, *m).is_none() => { + ExprF::Var(Var(y, m)) if ctx.lookup(y, *m).is_none() => { let delta = deltas.get(y).unwrap_or(&0); - in_expr.rewrap(Var(V(y.clone(), add_ui(*m, *delta)))) + in_expr.rewrap(ExprF::Var(Var(y.clone(), add_ui(*m, *delta)))) } _ => in_expr.map_subexprs_with_special_handling_of_binders( |e| shift0_multiple_inner(ctx, deltas, e), diff --git a/dhall_syntax/src/parser.rs b/dhall_syntax/src/parser.rs index 83ccc1e..bdef553 100644 --- a/dhall_syntax/src/parser.rs +++ b/dhall_syntax/src/parser.rs @@ -8,7 +8,13 @@ use std::rc::Rc; use dhall_generated_parser::{DhallParser, Rule}; -use crate::ExprF::*; +use crate::ExprF::{ + Annot, App, BinOp, BoolIf, BoolLit, Builtin, Const, DoubleLit, Embed, + EmptyListLit, Field, IntegerLit, Lam, Let, Merge, NEListLit, NaturalLit, + OldOptionalLit, Pi, Projection, RecordLit, RecordType, SomeLit, TextLit, + UnionLit, UnionType, +}; + use crate::*; // This file consumes the parse tree generated by pest and turns it into @@ -16,10 +22,10 @@ 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 = Expr<Span, Import>; -type ParsedSubExpr = SubExpr<Span, Import>; -type ParsedText = InterpolatedText<SubExpr<Span, Import>>; -type ParsedTextContents = InterpolatedTextContents<SubExpr<Span, Import>>; +type ParsedExpr = Expr<Label, Span, Import>; +type ParsedSubExpr = SubExpr<Label, Span, Import>; +type ParsedText = InterpolatedText<ParsedSubExpr>; +type ParsedTextContents = InterpolatedTextContents<ParsedSubExpr>; pub type ParseError = pest::error::Error<Rule>; @@ -504,17 +510,17 @@ make_parser! { rule!(identifier<ParsedSubExpr> as expression; span; children!( [variable(v)] => { - spanned(span, Var(v)) + spanned(span, ExprF::Var(v)) }, [builtin(e)] => e, )); - rule!(variable<V<Label>>; children!( + rule!(variable<Var<Label>>; children!( [label(l), natural_literal(idx)] => { - V(l, idx) + Var(l, idx) }, [label(l)] => { - V(l, 0) + Var(l, 0) }, )); diff --git a/dhall_syntax/src/printer.rs b/dhall_syntax/src/printer.rs index e3b180b..9cc1b46 100644 --- a/dhall_syntax/src/printer.rs +++ b/dhall_syntax/src/printer.rs @@ -3,7 +3,9 @@ use itertools::Itertools; use std::fmt::{self, Display}; /// Generic instance that delegates to subexpressions -impl<SE: Display + Clone, E: Display> Display for ExprF<SE, Label, E> { +impl<SE: Display + Clone, L: Display + Clone, E: Display> Display + for ExprF<SE, L, E> +{ fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> { use crate::ExprF::*; match self { @@ -13,9 +15,10 @@ impl<SE: Display + Clone, E: Display> Display for ExprF<SE, Label, E> { BoolIf(a, b, c) => { write!(f, "if {} then {} else {}", a, b, c)?; } - Pi(a, b, c) if &String::from(a) == "_" => { - write!(f, "{} → {}", b, c)?; - } + // TODO: arrow type + // Pi(a, b, c) if &String::from(a) == "_" => { + // write!(f, "{} → {}", b, c)?; + // } Pi(a, b, c) => { write!(f, "∀({} : {}) → {}", a, b, c)?; } @@ -124,21 +127,25 @@ enum PrintPhase { // Wraps an Expr with a phase, so that phase selsction can be done // separate from the actual printing #[derive(Clone)] -struct PhasedExpr<'a, S, A>(&'a SubExpr<S, A>, PrintPhase); +struct PhasedExpr<'a, L, S, A>(&'a SubExpr<L, S, A>, PrintPhase); -impl<'a, S: Clone, A: Display + Clone> Display for PhasedExpr<'a, S, A> { +impl<'a, L: Display + Clone, S: Clone, A: Display + Clone> Display + for PhasedExpr<'a, L, S, A> +{ fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> { self.0.as_ref().fmt_phase(f, self.1) } } -impl<'a, S: Clone, A: Display + Clone> PhasedExpr<'a, S, A> { - fn phase(self, phase: PrintPhase) -> PhasedExpr<'a, S, A> { +impl<'a, L: Display + Clone, S: Clone, A: Display + Clone> + PhasedExpr<'a, L, S, A> +{ + fn phase(self, phase: PrintPhase) -> PhasedExpr<'a, L, S, A> { PhasedExpr(self.0, phase) } } -impl<S: Clone, A: Display + Clone> Expr<S, A> { +impl<L: Display + Clone, S: Clone, A: Display + Clone> Expr<L, S, A> { fn fmt_phase( &self, f: &mut fmt::Formatter, @@ -172,11 +179,12 @@ impl<S: Clone, A: Display + Clone> Expr<S, A> { // Annotate subexpressions with the appropriate phase, defaulting to Base let phased_self = match self.map_ref_simple(|e| PhasedExpr(e, Base)) { Pi(a, b, c) => { - if &String::from(&a) == "_" { - Pi(a, b.phase(Operator), c) - } else { - Pi(a, b, c) - } + // TODO: arrow type + // if &String::from(&a) == "_" { + // Pi(a, b.phase(Operator), c) + // } else { + Pi(a, b, c) + // } } Merge(a, b, c) => Merge( a.phase(Import), @@ -212,7 +220,9 @@ impl<S: Clone, A: Display + Clone> Expr<S, A> { } } -impl<S: Clone, A: Display + Clone> Display for SubExpr<S, A> { +impl<L: Display + Clone, S: Clone, A: Display + Clone> Display + for SubExpr<L, S, A> +{ fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> { self.as_ref().fmt_phase(f, PrintPhase::Base) } @@ -474,9 +484,9 @@ impl Display for Scheme { } } -impl<Label: Display> Display for V<Label> { +impl<Label: Display> Display for Var<Label> { fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> { - let V(x, n) = self; + let Var(x, n) = self; x.fmt(f)?; if *n != 0 { write!(f, "@{}", n)?; diff --git a/dhall_syntax/src/visitor.rs b/dhall_syntax/src/visitor.rs index 7fdf217..a8e5a8c 100644 --- a/dhall_syntax/src/visitor.rs +++ b/dhall_syntax/src/visitor.rs @@ -48,8 +48,6 @@ pub trait ExprFVeryGenericVisitor<'a, Ret, SE1, L1, E1>: Sized { impl<'a, T, Ret, SE1, L1, E1> GenericVisitor<&'a ExprF<SE1, L1, E1>, Result<Ret, T::Error>> for T where - L1: Ord, - T::L2: Ord, T: ExprFVeryGenericVisitor<'a, Ret, SE1, L1, E1>, { fn visit(self, input: &'a ExprF<SE1, L1, E1>) -> Result<Ret, T::Error> { @@ -69,31 +67,27 @@ where }) } fn btmap<'a, V, Ret, SE, L, E>( - x: &'a BTreeMap<L, SE>, + x: &'a BTreeMap<Label, SE>, mut v: V, - ) -> Result<BTreeMap<V::L2, V::SE2>, V::Error> + ) -> Result<BTreeMap<Label, V::SE2>, V::Error> where - L: Ord, - V::L2: Ord, V: ExprFVeryGenericVisitor<'a, Ret, SE, L, E>, { x.iter() - .map(|(k, x)| Ok((v.visit_label(k)?, v.visit_subexpr(x)?))) + .map(|(k, x)| Ok((k.clone(), v.visit_subexpr(x)?))) .collect() } fn btoptmap<'a, V, Ret, SE, L, E>( - x: &'a BTreeMap<L, Option<SE>>, + x: &'a BTreeMap<Label, Option<SE>>, mut v: V, - ) -> Result<BTreeMap<V::L2, Option<V::SE2>>, V::Error> + ) -> Result<BTreeMap<Label, Option<V::SE2>>, V::Error> where - L: Ord, - V::L2: Ord, V: ExprFVeryGenericVisitor<'a, Ret, SE, L, E>, { x.iter() .map(|(k, x)| { Ok(( - v.visit_label(k)?, + k.clone(), match x { Some(x) => Some(v.visit_subexpr(x)?), None => None, @@ -104,9 +98,14 @@ where } let mut v = self; - use crate::ExprF::*; + use crate::ExprF::{ + Annot, App, BinOp, BoolIf, BoolLit, Builtin, Const, DoubleLit, + Embed, EmptyListLit, Field, IntegerLit, Lam, Let, Merge, NEListLit, + NaturalLit, OldOptionalLit, Pi, Projection, RecordLit, RecordType, + SomeLit, TextLit, UnionLit, UnionType, + }; T::visit_resulting_exprf(match input { - Var(V(l, n)) => Var(V(v.visit_label(l)?, *n)), + ExprF::Var(Var(l, n)) => ExprF::Var(Var(v.visit_label(l)?, *n)), Lam(l, t, e) => { let t = v.visit_subexpr(t)?; let (l, e) = v.visit_binder(l, e)?; @@ -150,20 +149,16 @@ where RecordType(kts) => RecordType(btmap(kts, v)?), RecordLit(kvs) => RecordLit(btmap(kvs, v)?), UnionType(kts) => UnionType(btoptmap(kts, v)?), - UnionLit(k, x, kts) => UnionLit( - v.visit_label(k)?, - v.visit_subexpr(x)?, - btoptmap(kts, v)?, - ), + UnionLit(l, x, kts) => { + UnionLit(l.clone(), v.visit_subexpr(x)?, btoptmap(kts, v)?) + } Merge(x, y, t) => Merge( v.visit_subexpr(x)?, v.visit_subexpr(y)?, opt(t, |e| v.visit_subexpr(e))?, ), - Field(e, l) => Field(v.visit_subexpr(e)?, v.visit_label(l)?), - Projection(e, ls) => { - Projection(v.visit_subexpr(e)?, vec(ls, |l| v.visit_label(l))?) - } + Field(e, l) => Field(v.visit_subexpr(e)?, l.clone()), + Projection(e, ls) => Projection(v.visit_subexpr(e)?, ls.clone()), Embed(a) => return v.visit_embed_squash(a), }) } @@ -314,8 +309,6 @@ where impl<'a, T, SE1, SE2, L1, L2, E1, E2> GenericVisitor<&'a ExprF<SE1, L1, E1>, ExprF<SE2, L2, E2>> for T where - L1: Ord, - L2: Ord, T: ExprFInFallibleVisitor<'a, SE1, SE2, L1, L2, E1, E2>, { fn visit(self, input: &'a ExprF<SE1, L1, E1>) -> ExprF<SE2, L2, E2> { @@ -337,8 +330,6 @@ where SE: 'a, L: 'a, E: 'a, - L: Ord, - L2: Ord, F1: FnMut(&'a SE) -> Result<SE2, Err>, F2: FnOnce(&'a L, &'a SE) -> Result<SE2, Err>, F4: FnOnce(&'a E) -> Result<E2, Err>, @@ -377,8 +368,6 @@ where SE: 'a, L: 'a, E: 'a, - L: Ord, - L2: Ord, F1: FnMut(&'a SE) -> Result<SE2, Err>, F3: FnOnce(&'a E) -> Result<E2, Err>, F4: FnMut(&'a L) -> Result<L2, Err>, @@ -398,10 +387,11 @@ where pub struct TraverseEmbedVisitor<F1>(pub F1); -impl<'a, 'b, N, E, E2, Err, F1> - ExprFFallibleVisitor<'a, SubExpr<N, E>, SubExpr<N, E2>, Label, Label, E, E2> +impl<'a, 'b, L, N, E, E2, Err, F1> + ExprFFallibleVisitor<'a, SubExpr<L, N, E>, SubExpr<L, N, E2>, L, L, E, E2> for &'b mut TraverseEmbedVisitor<F1> where + L: Clone + 'a, N: Clone + 'a, F1: FnMut(&E) -> Result<E2, Err>, { @@ -409,50 +399,48 @@ where fn visit_subexpr( &mut self, - subexpr: &'a SubExpr<N, E>, - ) -> Result<SubExpr<N, E2>, Self::Error> { + subexpr: &'a SubExpr<L, N, E>, + ) -> Result<SubExpr<L, N, E2>, Self::Error> { Ok(subexpr.rewrap(subexpr.as_ref().visit(&mut **self)?)) } fn visit_embed(self, embed: &'a E) -> Result<E2, Self::Error> { (self.0)(embed) } - fn visit_label(&mut self, label: &'a Label) -> Result<Label, Self::Error> { - Ok(Label::clone(label)) + fn visit_label(&mut self, label: &'a L) -> Result<L, Self::Error> { + Ok(L::clone(label)) } } pub struct SquashEmbedVisitor<F1>(pub F1); -impl<'a, 'b, N, E1, E2, F1> - ExprFVeryGenericVisitor<'a, SubExpr<N, E2>, SubExpr<N, E1>, Label, E1> +impl<'a, 'b, L, N, E1, E2, F1> + ExprFVeryGenericVisitor<'a, SubExpr<L, N, E2>, SubExpr<L, N, E1>, L, E1> for &'b mut SquashEmbedVisitor<F1> where + L: Clone + 'a, N: Clone + 'a, - F1: FnMut(&E1) -> SubExpr<N, E2>, + F1: FnMut(&E1) -> SubExpr<L, N, E2>, { type Error = X; - type SE2 = SubExpr<N, E2>; - type L2 = Label; + type SE2 = SubExpr<L, N, E2>; + type L2 = L; type E2 = E2; fn visit_subexpr( &mut self, - subexpr: &'a SubExpr<N, E1>, + subexpr: &'a SubExpr<L, N, E1>, ) -> Result<Self::SE2, Self::Error> { Ok(subexpr.as_ref().visit(&mut **self)?) } - fn visit_label( - &mut self, - label: &'a Label, - ) -> Result<Self::L2, Self::Error> { - Ok(Label::clone(label)) + fn visit_label(&mut self, label: &'a L) -> Result<Self::L2, Self::Error> { + Ok(L::clone(label)) } fn visit_binder( mut self, - label: &'a Label, - subexpr: &'a SubExpr<N, E1>, + label: &'a L, + subexpr: &'a SubExpr<L, N, E1>, ) -> Result<(Self::L2, Self::SE2), Self::Error> { Ok((self.visit_label(label)?, self.visit_subexpr(subexpr)?)) } @@ -460,7 +448,7 @@ where fn visit_embed_squash( self, embed: &'a E1, - ) -> Result<SubExpr<N, E2>, Self::Error> { + ) -> Result<SubExpr<L, N, E2>, Self::Error> { Ok((self.0)(embed)) } @@ -468,7 +456,7 @@ where // Useful to change the result type, and/or avoid some loss of info fn visit_resulting_exprf( result: ExprF<Self::SE2, Self::L2, Self::E2>, - ) -> Result<SubExpr<N, E2>, Self::Error> { + ) -> Result<SubExpr<L, N, E2>, Self::Error> { // TODO: don't lose note Ok(SubExpr::from_expr_no_note(result)) } @@ -476,57 +464,69 @@ where pub struct UnNoteVisitor; -impl<'a, 'b, N, E> - ExprFInFallibleVisitor<'a, SubExpr<N, E>, SubExpr<X, E>, Label, Label, E, E> +impl<'a, 'b, L, N, E> + ExprFInFallibleVisitor<'a, SubExpr<L, N, E>, SubExpr<L, X, E>, L, L, E, E> for &'b mut UnNoteVisitor where + L: Clone + 'a, E: Clone + 'a, { - fn visit_subexpr(&mut self, subexpr: &'a SubExpr<N, E>) -> SubExpr<X, E> { + fn visit_subexpr( + &mut self, + subexpr: &'a SubExpr<L, N, E>, + ) -> SubExpr<L, X, E> { 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) + fn visit_label(&mut self, label: &'a L) -> L { + L::clone(label) } } pub struct NoteAbsurdVisitor; -impl<'a, 'b, N, E> - ExprFInFallibleVisitor<'a, SubExpr<X, E>, SubExpr<N, E>, Label, Label, E, E> +impl<'a, 'b, L, N, E> + ExprFInFallibleVisitor<'a, SubExpr<L, X, E>, SubExpr<L, N, E>, L, L, E, E> for &'b mut NoteAbsurdVisitor where + L: Clone + 'a, E: Clone + 'a, { - fn visit_subexpr(&mut self, subexpr: &'a SubExpr<X, E>) -> SubExpr<N, E> { + fn visit_subexpr( + &mut self, + subexpr: &'a SubExpr<L, X, E>, + ) -> SubExpr<L, N, E> { 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) + fn visit_label(&mut self, label: &'a L) -> L { + L::clone(label) } } pub struct EmbedAbsurdVisitor; -impl<'a, 'b, N, E> - ExprFInFallibleVisitor<'a, SubExpr<N, X>, SubExpr<N, E>, Label, Label, X, E> +impl<'a, 'b, L, N, E> + ExprFInFallibleVisitor<'a, SubExpr<L, N, X>, SubExpr<L, N, E>, L, L, X, E> for &'b mut EmbedAbsurdVisitor where + L: Clone + 'a, N: Clone + 'a, { - fn visit_subexpr(&mut self, subexpr: &'a SubExpr<N, X>) -> SubExpr<N, E> { + fn visit_subexpr( + &mut self, + subexpr: &'a SubExpr<L, N, X>, + ) -> SubExpr<L, N, E> { subexpr.rewrap(subexpr.as_ref().visit(&mut **self)) } fn visit_embed(self, embed: &'a X) -> E { match *embed {} } - fn visit_label(&mut self, label: &'a Label) -> Label { - Label::clone(label) + fn visit_label(&mut self, label: &'a L) -> L { + L::clone(label) } } |