Refactor again to take advantage of impl Trait.

Will pursue mixed mergers through methods other than direct dyn
Compatibility of Source trait.

diff --git a/src/dupsort.rs b/src/dupsort.rs
index 04b449fa87093e8a4146fddc5d858c48ada971bf..3c05b604073f447c582bba2192b3195f387c9fef 100644 (file)
--- a/src/dupsort.rs
+++ b/src/dupsort.rs
@@ -7,10 +7,7 @@ where
 {
     source: S,
     #[allow(clippy::type_complexity)]
-    // Attempting to factor out the `::Item` type removes the ability to use the
-    // implicit '_ lifetime.
-    dupsort_func:
-        Box<dyn Fn(&<S::Iter<'_> as Iterator>::Item, &<S::Iter<'_> as Iterator>::Item) -> Ordering>,
+    dupsort_func: Box<dyn Fn(&S::Item, &S::Item) -> Ordering>,
 }
 
 impl<S> DupsortSource<S>
@@ -19,8 +16,7 @@ where
 {
     pub fn new<F>(source: S, dupsort_func: F) -> Self
     where
-        F: Fn(&<S::Iter<'_> as Iterator>::Item, &<S::Iter<'_> as Iterator>::Item) -> Ordering
-            + 'static,
+        F: Fn(&S::Item, &S::Item) -> Ordering + 'static,
     {
         Self {
             source,
@@ -31,15 +27,11 @@ where
 
 impl<S> Source for DupsortSource<S>
 where
-    S: Source + 'static,
-    for<'i> <S::Iter<'i> as Iterator>::Item: PartialEq,
+    S: Source,
+    S::Item: PartialEq,
 {
-    type Iter<'i> = DupsortIter<
-        S::Iter<'i>,
-        &'i dyn Fn(&<S::Iter<'_> as Iterator>::Item, &<S::Iter<'_> as Iterator>::Item) -> Ordering,
-    >;
-
-    fn iter(&self) -> Self::Iter<'_> {
+    type Item = S::Item;
+    fn iter(&self) -> impl SeekableIter<Item = Self::Item> {
         self.source.iter().dupsort_func(&self.dupsort_func)
     }
 }

diff --git a/src/filter.rs b/src/filter.rs
index b420c218a36bed5c1a33a5df6243e23147b916a5..9d224f6d09ba0e7f12aebb33159d8e2c388612c6 100644 (file)
--- a/src/filter.rs
+++ b/src/filter.rs
@@ -58,7 +58,7 @@ where
 {
     source: S,
     #[allow(clippy::type_complexity)]
-    filter_func: Box<dyn Fn(&<S::Iter<'_> as Iterator>::Item, &mut Vec<u8>) -> bool>,
+    filter_func: Box<dyn Fn(&S::Item, &mut Vec<u8>) -> bool>,
 }
 
 impl<S> FilterSource<S>
@@ -67,7 +67,7 @@ where
 {
     pub fn new<F>(source: S, filter_func: F) -> Self
     where
-        F: Fn(&<S::Iter<'_> as Iterator>::Item, &mut Vec<u8>) -> bool + 'static,
+        F: Fn(&S::Item, &mut Vec<u8>) -> bool + 'static,
     {
         Self {
             source,
@@ -78,11 +78,10 @@ where
 
 impl<S> Source for FilterSource<S>
 where
-    S: Source + 'static,
+    S: Source,
 {
-    type Iter<'i> =
-        FilterIter<S::Iter<'i>, &'i dyn Fn(&<S::Iter<'_> as Iterator>::Item, &mut Vec<u8>) -> bool>;
-    fn iter(&self) -> Self::Iter<'_> {
+    type Item = S::Item;
+    fn iter(&self) -> impl SeekableIter<Item = Self::Item> {
         self.source.iter().filter_func(&self.filter_func)
     }
 }

diff --git a/src/merge.rs b/src/merge.rs
index e6f79ddc94642060e26e62fc691587000a5ff93f..ae26304d21d9e5e88f2dc02e93401a3c7073ce19 100644 (file)
--- a/src/merge.rs
+++ b/src/merge.rs
@@ -22,11 +22,10 @@ where
 }
 impl<S> Source for MergeSource<S>
 where
-    S: Source + 'static,
-    for<'a> S::Iter<'a>: Iterator<Item = Entry>,
+    S: Source<Item = Entry>,
 {
-    type Iter<'i> = MergeIter<S::Iter<'i>, &'i dyn Fn(&mut Vec<u8>, &Entry)>;
-    fn iter(&self) -> Self::Iter<'_> {
+    type Item = S::Item;
+    fn iter(&self) -> impl SeekableIter<Item = Self::Item> {
         self.source.iter().merge_func(&self.merge_func)
     }
 }

diff --git a/src/merger.rs b/src/merger.rs
index 6d611f6ebc7ecf349c1e70d669ab3caf18054cf9..5d9e371b7e43d1edc01df193fd22792d1528e10f 100644 (file)
--- a/src/merger.rs
+++ b/src/merger.rs
@@ -136,11 +136,10 @@ impl<I: SeekableIter<Item = Entry>> SeekableIter for MergeIter<I> {
 
 impl<S> Source for Merger<S>
 where
-    S: Source + 'static,
-    for<'i> S::Iter<'i>: Iterator<Item = Entry> + 'i,
+    S: Source<Item = Entry>,
 {
-    type Iter<'i> = MergeIter<S::Iter<'i>>;
-    fn iter(&self) -> Self::Iter<'_> {
+    type Item = S::Item;
+    fn iter(&self) -> impl SeekableIter<Item = Self::Item> {
         MergeIter::from(self.sources.iter().map(|s| s.iter()))
     }
 }

diff --git a/src/reader/mod.rs b/src/reader/mod.rs
index d956d5169d4e4138aa14a873f4b344e4d248aed8..4ba0d7ebc82b1e7c4f1983ed6dacd1ce14a637e4 100644 (file)
--- a/src/reader/mod.rs
+++ b/src/reader/mod.rs
@@ -177,12 +177,9 @@ impl<D: AsRef<[u8]>> SeekableIter for ReaderIter<D> {
 }
 
 impl<D: AsRef<[u8]>> Source for Reader<D> {
-    type Iter<'i>
-        = ReaderIter<D>
-    where
-        D: 'i;
+    type Item = Entry;
 
-    fn iter(&self) -> Self::Iter<'_> {
+    fn iter(&self) -> impl SeekableIter<Item = Self::Item> {
         ReaderIter {
             reader: self.clone(),
             next_offset: 0,

diff --git a/src/source.rs b/src/source.rs
index 23ea66f27d2470b0d073ccf614e39d549f015a24..adefa73b33506a26f71470d4a69e2398c76d84c3 100644 (file)
--- a/src/source.rs
+++ b/src/source.rs
@@ -5,26 +5,24 @@ use crate::merge::MergeSource;
 use crate::{Entry, SeekableIter};
 
 pub trait Source {
-    type Iter<'i>: SeekableIter
-    where
-        Self: 'i;
+    type Item;
 
-    fn iter(&self) -> Self::Iter<'_>;
-    fn get(&self, key: &[u8]) -> RangeIter<Self::Iter<'_>>
+    fn iter(&self) -> impl SeekableIter<Item = Self::Item>;
+    fn get(&self, key: &[u8]) -> RangeIter<impl SeekableIter<Item = Self::Item>>
     where
-        for<'a> <Self::Iter<'a> as Iterator>::Item: PartialOrd<[u8]>,
+        Self::Item: PartialOrd<[u8]>,
     {
         RangeIter::new(self.iter(), key, key)
     }
-    fn get_prefix(&self, prefix: &[u8]) -> PrefixIter<Self::Iter<'_>>
+    fn get_prefix(&self, prefix: &[u8]) -> PrefixIter<impl SeekableIter<Item = Self::Item>>
     where
-        for<'a> <Self::Iter<'a> as Iterator>::Item: AsRef<[u8]>,
+        Self::Item: AsRef<[u8]>,
     {
         PrefixIter::new(self.iter(), prefix)
     }
-    fn get_range(&self, start: &[u8], end: &[u8]) -> RangeIter<Self::Iter<'_>>
+    fn get_range(&self, start: &[u8], end: &[u8]) -> RangeIter<impl SeekableIter<Item = Self::Item>>
     where
-        for<'a> <Self::Iter<'a> as Iterator>::Item: PartialOrd<[u8]>,
+        Self::Item: PartialOrd<[u8]>,
     {
         RangeIter::new(self.iter(), start, end)
     }
@@ -40,11 +38,7 @@ pub trait Source {
     fn dupsort_func<F>(self, dupsort_func: F) -> DupsortSource<Self>
     where
         Self: Sized,
-        F: Fn(
-                &<Self::Iter<'_> as Iterator>::Item,
-                &<Self::Iter<'_> as Iterator>::Item,
-            ) -> std::cmp::Ordering
-            + 'static,
+        F: Fn(&Self::Item, &Self::Item) -> std::cmp::Ordering + 'static,
     {
         DupsortSource::new(self, dupsort_func)
     }
@@ -52,15 +46,15 @@ pub trait Source {
     fn filter<F>(self, filter_func: F) -> FilterSource<Self>
     where
         Self: Sized,
-        F: Fn(&<Self::Iter<'_> as Iterator>::Item, &mut Vec<u8>) -> bool + 'static,
+        F: Fn(&Self::Item, &mut Vec<u8>) -> bool + 'static,
     {
         FilterSource::new(self, filter_func)
     }
 }
 
-impl<S: Source + ?Sized + 'static> Source for Box<S> {
-    type Iter<'i> = Box<dyn SeekableIter<Item = <S::Iter<'i> as Iterator>::Item> + 'i>;
-    fn iter(&self) -> Self::Iter<'_> {
+impl<S: Source + ?Sized> Source for Box<S> {
+    type Item = S::Item;
+    fn iter(&self) -> impl SeekableIter<Item = Self::Item> {
         Box::new(self.as_ref().iter())
     }
 }
@@ -100,8 +94,8 @@ impl SeekableIter for VecIter<'_> {
 }
 
 impl Source for Vec<Entry> {
-    type Iter<'i> = VecIter<'i>;
-    fn iter(&self) -> Self::Iter<'_> {
+    type Item = Entry;
+    fn iter(&self) -> impl SeekableIter<Item = Self::Item> {
         VecIter {
             index: 0,
             vec: self,
@@ -145,8 +139,8 @@ pub mod test_source {
     }
 
     impl Source for TestSource {
-        type Iter<'i> = TestIter<'i>;
-        fn iter(&self) -> Self::Iter<'_> {
+        type Item = Entry;
+        fn iter(&self) -> impl SeekableIter<Item = Self::Item> {
             TestIter {
                 source: self,
                 off: 0,