redefine Tree::Children as a GAT

Author: brunocodutra

benches/diff.rs

@@ -10,19 +10,19 @@ struct TreeNode {
     children: Vec<Self>,
 }
 
-impl<'n> Node<'n> for TreeNode {
+impl Node for TreeNode {
     type Kind = ();
-    fn kind(&'n self) -> Self::Kind {}
+    fn kind(&self) -> Self::Kind {}
 
     type Weight = u32;
-    fn weight(&'n self) -> Self::Weight {
+    fn weight(&self) -> Self::Weight {
         self.weight.into()
     }
 }
 
-impl<'t> Tree<'t> for TreeNode {
-    type Children = &'t [Self];
-    fn children(&'t self) -> Self::Children {
+impl Tree for TreeNode {
+    type Children<'c> = &'c [Self];
+    fn children(&self) -> Self::Children<'_> {
         &self.children
     }
 }

src/diff.rs

@@ -18,10 +18,9 @@ impl<T: Default + Eq + Add<Output = T>> Zero for WholeNumber<T> {
     }
 }
 
-fn levenshtein<'t, T, W>(a: &'t [T], b: &'t [T]) -> (Box<[Edit]>, W)
+fn levenshtein<'c, T>(a: &'c [T], b: &'c [T]) -> (Box<[Edit]>, T::Weight)
 where
-    T: Tree<'t, Weight = W, Children = &'t [T]> + Cost<Output = W>,
-    W: Default + Copy + Ord + Add<Output = W>,
+    T: Tree<Children<'c> = &'c [T]> + Cost<Output = T::Weight>,
 {
     let mut edges = HashMap::new();
 
@@ -89,11 +88,7 @@ where
 ///
 /// The sequence of [Edit]s is understood to apply to the left-hand side so it becomes the
 /// right-hand side.
-pub fn diff<T, W>(a: &T, b: &T) -> (Box<[Edit]>, W)
-where
-    T: for<'t> Tree<'t, Weight = W>,
-    W: Default + Copy + Ord + Add<Output = W>,
-{
+pub fn diff<T: Tree>(a: &T, b: &T) -> (Box<[Edit]>, T::Weight) {
     levenshtein(&[memoize(a)], &[memoize(b)])
 }
 
@@ -105,10 +100,10 @@ mod tests {
     use proptest::collection::size_range;
     use test_strategy::{proptest, Arbitrary};
 
-    #[derive(Debug, Default, Clone, Eq, PartialEq, Arbitrary)]
+    #[derive(Debug, Default, Copy, Clone, Eq, PartialEq, Arbitrary)]
     struct Eq;
 
-    #[derive(Debug, Default, Clone, Arbitrary)]
+    #[derive(Debug, Default, Copy, Clone, Arbitrary)]
     struct NotEq;
 
     impl PartialEq for NotEq {

src/lib.rs

@@ -24,7 +24,7 @@
 //!     Map(Vec<(String, Json)>),
 //! }
 //!
-//! impl<'n> Node<'n> for Json {
+//! impl Node for Json {
 //!     type Kind = Discriminant<Json>;
 //!     fn kind(&self) -> Self::Kind {
 //!         discriminant(self)
@@ -36,9 +36,12 @@
 //!     }
 //! }
 //!
-//! impl<'t> Tree<'t> for Json {
-//!     type Children = Box<dyn Iterator<Item = &'t Self> + 't>;
-//!     fn children(&'t self) -> Self::Children {
+//! impl Tree for Json {
+//!     type Children<'c> = Box<dyn Iterator<Item = &'c Self> + 'c>
+//!     where
+//!         Self: 'c;
+//!
+//!     fn children(&self) -> Self::Children<'_> {
 //!         match self {
 //!             Json::Array(a) => Box::new(a.iter()),
 //!             Json::Map(m) => Box::new(m.iter().map(|(_, v)| v)),

src/memoize.rs

@@ -1,52 +1,49 @@
 use crate::{Cost, Node, Tree};
-use std::ops::Add;
 
 #[derive(Debug, Clone, Eq, PartialEq, Hash)]
-pub(crate) struct Memoized<'t, T: Tree<'t>> {
+pub(crate) struct Memoized<'t, T: 't + Tree> {
     tree: &'t T,
     cost: T::Weight,
     children: Box<[Self]>,
 }
 
-impl<'t, T: 't + Tree<'t>> Node<'t> for Memoized<'t, T> {
+impl<'t, T: 't + Tree> Node for Memoized<'t, T> {
     type Kind = T::Kind;
 
     #[inline]
-    fn kind(&'t self) -> Self::Kind {
+    fn kind(&self) -> Self::Kind {
         T::kind(self.tree)
     }
 
     type Weight = T::Weight;
 
     #[inline]
-    fn weight(&'t self) -> Self::Weight {
+    fn weight(&self) -> Self::Weight {
         T::weight(self.tree)
     }
 }
 
-impl<'t, T: 't + Tree<'t>> Tree<'t> for Memoized<'t, T> {
-    type Children = &'t [Self];
+impl<'t, T: 't + Tree> Tree for Memoized<'t, T> {
+    type Children<'c> = &'c [Self]
+    where
+        Self: 'c;
 
     #[inline]
-    fn children(&'t self) -> Self::Children {
+    fn children(&self) -> Self::Children<'_> {
         &self.children
     }
 }
 
-impl<'t, T: Tree<'t, Weight = W>, W: Copy + Default + Add<Output = W>> Cost for Memoized<'t, T> {
-    type Output = W;
+impl<'t, T: 't + Tree> Cost for Memoized<'t, T> {
+    type Output = T::Weight;
 
     #[inline]
     fn cost(&self) -> Self::Output {
         self.cost
     }
 }
 
-pub(crate) fn memoize<T, W>(t: &T) -> Memoized<T>
-where
-    T: for<'t> Tree<'t, Weight = W>,
-    W: Copy + Default + Add<Output = W>,
-{
+pub(crate) fn memoize<T: Tree>(t: &T) -> Memoized<T> {
     let children: Box<[_]> = t.children().into_iter().map(memoize).collect();
 
     Memoized {
@@ -63,17 +60,17 @@ mod tests {
     use test_strategy::proptest;
 
     #[proptest]
-    fn kind_is_preserved(t: MockTree<()>) {
+    fn kind_is_preserved(t: MockTree<u8>) {
         assert_eq!(memoize(&t).kind(), t.kind());
     }
 
     #[proptest]
-    fn weight_is_preserved(t: MockTree<()>) {
+    fn weight_is_preserved(t: MockTree<u8>) {
         assert_eq!(memoize(&t).weight(), t.weight());
     }
 
     #[proptest]
-    fn cost_is_memoized(t: MockTree<()>) {
+    fn cost_is_memoized(t: MockTree<u8>) {
         let u = memoize(&t);
         assert_eq!(u.cost, t.cost());
         assert_eq!(u.cost, u.cost());

src/tree.rs

@@ -1,14 +1,14 @@
 use std::ops::Add;
 
 /// An abstraction for a generic tree node.
-pub trait Node<'n> {
+pub trait Node {
     /// The type of this [Node]'s [kind][Node::kind].
     ///
     /// Only [Node]s of the equal _kind_ can replace each other.
     type Kind: PartialEq;
 
     /// Returns this [Node]'s _kind_.
-    fn kind(&'n self) -> Self::Kind;
+    fn kind(&self) -> Self::Kind;
 
     /// The type of this [Node]'s [weight][Node::weight].
     ///
@@ -18,16 +18,18 @@ pub trait Node<'n> {
     /// Returns the cost of inserting or deleting this [Node].
     ///
     /// A [Node]'s weight should be independent of the weight of its children.
-    fn weight(&'n self) -> Self::Weight;
+    fn weight(&self) -> Self::Weight;
 }
 
 /// An abstraction for a recursive tree.
-pub trait Tree<'t>: 't + Node<'t> {
+pub trait Tree: Node {
     /// A type that can iterate over this [Tree]'s [children][Tree::children].
-    type Children: IntoIterator<Item = &'t Self>;
+    type Children<'c>: 'c + IntoIterator<Item = &'c Self>
+    where
+        Self: 'c;
 
     /// Returns this [Tree]'s immediate children.
-    fn children(&'t self) -> Self::Children;
+    fn children(&self) -> Self::Children<'_>;
 }
 
 #[cfg(test)]
@@ -58,7 +60,10 @@ mod tests {
         }
     }
 
-    fn tree<K: 'static + PartialEq + Arbitrary>(size: Size) -> impl Strategy<Value = MockTree<K>> {
+    fn tree<K>(size: Size) -> impl Strategy<Value = MockTree<K>>
+    where
+        K: 'static + Copy + PartialEq + Arbitrary,
+    {
         let depth = size.depth as u32;
         let breadth = size.breadth as u32;
         let size = (breadth.pow(depth + 1) - 1) / (breadth - 1) / 2; // half the maximum number of nodes
@@ -71,13 +76,13 @@ mod tests {
     }
 
     #[derive(Debug, Default, Clone, PartialEq, Eq, Hash, From)]
-    pub(crate) struct MockTree<K: PartialEq> {
+    pub(crate) struct MockTree<K: Copy + PartialEq> {
         kind: K,
         weight: u8,
         children: Vec<Self>,
     }
 
-    impl<K: 'static + PartialEq + Arbitrary> Arbitrary for MockTree<K> {
+    impl<K: 'static + Copy + PartialEq + Arbitrary> Arbitrary for MockTree<K> {
         type Parameters = Size;
         type Strategy = BoxedStrategy<Self>;
 
@@ -86,39 +91,36 @@ mod tests {
         }
     }
 
-    impl<'n, K: 'n + PartialEq> Node<'n> for MockTree<K> {
-        type Kind = &'n K;
-        fn kind(&'n self) -> Self::Kind {
-            &self.kind
+    impl<K: Copy + PartialEq> Node for MockTree<K> {
+        type Kind = K;
+        fn kind(&self) -> Self::Kind {
+            self.kind
         }
 
         type Weight = u64;
-        fn weight(&'n self) -> Self::Weight {
+        fn weight(&self) -> Self::Weight {
             self.weight.into()
         }
     }
 
-    impl<'t, K: 't + PartialEq> Tree<'t> for MockTree<K> {
-        type Children = &'t [Self];
-        fn children(&'t self) -> Self::Children {
+    impl<K: Copy + PartialEq> Tree for MockTree<K> {
+        type Children<'c> = &'c [Self]
+        where
+            Self: 'c;
+
+        fn children(&self) -> Self::Children<'_> {
             &self.children
         }
     }
 
-    impl<K: PartialEq> Fold for MockTree<K>
-    where
-        Self: for<'t> Tree<'t, Children = &'t [Self]>,
-    {
+    impl<K: Copy + PartialEq> Fold for MockTree<K> {
         fn fold<R, Fn: FnMut(R, &Self) -> R>(&self, init: R, f: &mut Fn) -> R {
             self.children().fold(f(init, self), f)
         }
     }
 
-    impl<K: PartialEq, W: Default + Copy + Add<Output = W>> Cost for MockTree<K>
-    where
-        Self: for<'t> Tree<'t, Weight = W, Children = &'t [Self]>,
-    {
-        type Output = W;
+    impl<K: Copy + PartialEq> Cost for MockTree<K> {
+        type Output = <Self as Node>::Weight;
 
         #[inline]
         fn cost(&self) -> Self::Output {