Reduced code duplication and added impl for SourceIter and InPlaceIterable

Author: slerpyyy

library/core/src/iter/adapters/dedup.rs

@@ -1,97 +1,121 @@
-use crate::mem::swap;
+use crate::{
+    iter::{InPlaceIterable, SourceIter},
+    mem::swap,
+};
 
-/// An iterator that removes all but the first of consecutive elements in a
-/// given iterator according to the [`PartialEq`] trait implementation.
+/// A wrapper type around a key function.
 ///
-/// This `struct` is created by [`Iterator::dedup`].
+/// This struct acts like a function which given a key function returns true
+/// if and only if both arguments evaluate to the same key.
+///
+/// This `struct` is created by [`Iterator::dedup_by_key`].
 /// See its documentation for more.
 ///
-/// [`Iterator::dedup`]: Iterator::dedup
+/// [`Iterator::dedup_by_key`]: Iterator::dedup_by_key
 #[unstable(feature = "iter_dedup", reason = "recently added", issue = "83748")]
 #[derive(Debug, Clone, Copy)]
-pub struct Dedup<I, T> {
-    inner: I,
-    last: Option<T>,
+pub struct ByKey<F> {
+    key: F,
+}
+
+impl<F> ByKey<F> {
+    pub(crate) fn new(key: F) -> Self {
+        Self { key }
+    }
 }
 
-impl<I, T> Dedup<I, T>
+#[unstable(feature = "iter_dedup", reason = "recently added", issue = "83748")]
+impl<F, T, K> FnOnce<(&T, &T)> for ByKey<F>
 where
-    I: Iterator<Item = T>,
+    F: FnMut(&T) -> K,
+    K: PartialEq,
 {
-    pub(crate) fn new(inner: I) -> Self {
-        let mut inner = inner;
-        Self { last: inner.next(), inner }
+    type Output = bool;
+
+    extern "rust-call" fn call_once(mut self, args: (&T, &T)) -> Self::Output {
+        (self.key)(args.0) == (self.key)(args.1)
     }
 }
 
 #[unstable(feature = "iter_dedup", reason = "recently added", issue = "83748")]
-impl<I, T> Iterator for Dedup<I, T>
+impl<F, T, K> FnMut<(&T, &T)> for ByKey<F>
 where
-    I: Iterator<Item = T>,
-    T: PartialEq,
+    F: FnMut(&T) -> K,
+    K: PartialEq,
 {
-    type Item = T;
+    extern "rust-call" fn call_mut(&mut self, args: (&T, &T)) -> Self::Output {
+        (self.key)(args.0) == (self.key)(args.1)
+    }
+}
 
-    fn next(&mut self) -> Option<Self::Item> {
-        let last_item = self.last.as_ref()?;
-        let mut next = loop {
-            let curr = self.inner.next();
-            if let Some(curr_item) = &curr {
-                if last_item != curr_item {
-                    break curr;
-                }
-            } else {
-                break None;
-            }
-        };
+/// A zero-sized type for checking partial equality.
+///
+/// This struct acts exactly like the function [`PartialEq::eq`], but its
+/// type is always known during compile time.
+///
+/// This `struct` is created by [`Iterator::dedup`].
+/// See its documentation for more.
+///
+/// [`Iterator::dedup`]: Iterator::dedup
+#[unstable(feature = "iter_dedup", reason = "recently added", issue = "83748")]
+#[derive(Debug, Clone, Copy)]
+pub struct ByPartialEq;
 
-        swap(&mut self.last, &mut next);
-        next
+impl ByPartialEq {
+    pub(crate) fn new() -> Self {
+        Self
     }
+}
 
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        if self.last.is_some() {
-            // If we have a last item stored, the iterator can yield at most
-            // as many items at the inner iterator plus the stored one. Yet we
-            // can only guarantee that the iterator yields at least one more item
-            // since all other items in the inner iterator might be duplicates.
-            let (_, max) = self.inner.size_hint();
-            (1, max.and_then(|k| k.checked_add(1)))
-        } else {
-            // If the last item we got from the inner iterator is `None`,
-            // the iterator is empty.
-            (0, Some(0))
-        }
+#[unstable(feature = "iter_dedup", reason = "recently added", issue = "83748")]
+impl<T: PartialEq> FnOnce<(&T, &T)> for ByPartialEq {
+    type Output = bool;
+
+    extern "rust-call" fn call_once(self, args: (&T, &T)) -> Self::Output {
+        args.0 == args.1
+    }
+}
+
+#[unstable(feature = "iter_dedup", reason = "recently added", issue = "83748")]
+impl<T: PartialEq> FnMut<(&T, &T)> for ByPartialEq {
+    extern "rust-call" fn call_mut(&mut self, args: (&T, &T)) -> Self::Output {
+        args.0 == args.1
     }
 }
 
 /// An iterator that removes all but the first of consecutive elements in a
 /// given iterator satisfying a given equality relation.
 ///
-/// This `struct` is created by [`Iterator::dedup_by`].
-/// See its documentation for more.
+/// This `struct` is created by [`Iterator::dedup`], [`Iterator::dedup_by`]
+/// and [`Iterator::dedup_by_key`]. See its documentation for more.
 ///
+/// [`Iterator::dedup`]: Iterator::dedup
 /// [`Iterator::dedup_by`]: Iterator::dedup_by
+/// [`Iterator::dedup_by_key`]: Iterator::dedup_by_key
 #[unstable(feature = "iter_dedup", reason = "recently added", issue = "83748")]
 #[derive(Debug, Clone, Copy)]
-pub struct DedupBy<I, F, T> {
+pub struct Dedup<I, F, T> {
     inner: I,
     same_bucket: F,
     last: Option<T>,
 }
 
-impl<I, F, T> DedupBy<I, F, T>
+impl<I, F, T> Dedup<I, F, T>
 where
     I: Iterator<Item = T>,
 {
     pub(crate) fn new(inner: I, same_bucket: F) -> Self {
         let mut inner = inner;
-        Self { last: inner.next(), inner, same_bucket }
+        Self {
+            last: inner.next(),
+            inner,
+            same_bucket,
+        }
     }
 }
 
 #[unstable(feature = "iter_dedup", reason = "recently added", issue = "83748")]
-impl<I, F, T> Iterator for DedupBy<I, F, T>
+impl<I, F, T> Iterator for Dedup<I, F, T>
 where
     I: Iterator<Item = T>,
     F: FnMut(&T, &T) -> bool,
@@ -116,84 +140,30 @@ where
     }
 
     fn size_hint(&self) -> (usize, Option<usize>) {
-        if self.last.is_some() {
-            // If we have a last item stored, the iterator can yield at most
-            // as many items at the inner iterator plus the stored one. Yet we
-            // can only guarantee that the iterator yields at least one more item
-            // since all other items in the inner iterator might be duplicates.
-            let (_, max) = self.inner.size_hint();
-            (1, max.and_then(|k| k.checked_add(1)))
-        } else {
-            // If the last item we got from the inner iterator is `None`,
-            // the iterator is empty.
-            (0, Some(0))
-        }
+        let min = self.last.as_ref().map(|_| 1).unwrap_or(0);
+        let max = self.inner.size_hint().1;
+        (min, max)
     }
 }
 
-/// An iterator that removes all but the first of consecutive elements in a
-/// given iterator that resolve to the same key.
-///
-/// This `struct` is created by [`Iterator::dedup_by_key`].
-/// See its documentation for more.
-///
-/// [`Iterator::dedup_by_key`]: Iterator::dedup_by_key
 #[unstable(feature = "iter_dedup", reason = "recently added", issue = "83748")]
-#[derive(Debug, Clone, Copy)]
-pub struct DedupByKey<I, F, T> {
-    inner: I,
-    key: F,
-    last: Option<T>,
-}
-
-impl<I, F, T> DedupByKey<I, F, T>
+unsafe impl<S, I, F, T> SourceIter for Dedup<I, F, T>
 where
-    I: Iterator<Item = T>,
+    S: Iterator,
+    I: Iterator + SourceIter<Source = S>,
 {
-    pub(crate) fn new(inner: I, key: F) -> Self {
-        let mut inner = inner;
-        Self { last: inner.next(), inner, key }
+    type Source = S;
+
+    unsafe fn as_inner(&mut self) -> &mut Self::Source {
+        // SAFETY: unsafe function forwarding to unsafe function with the same requirements
+        unsafe { SourceIter::as_inner(&mut self.inner) }
     }
 }
 
 #[unstable(feature = "iter_dedup", reason = "recently added", issue = "83748")]
-impl<I, F, K, T> Iterator for DedupByKey<I, F, T>
+unsafe impl<I, F, T> InPlaceIterable for Dedup<I, F, T>
 where
-    I: Iterator<Item = T>,
-    F: FnMut(&T) -> K,
-    K: PartialEq,
+    I: InPlaceIterable<Item = T>,
+    F: FnMut(&T, &T) -> bool,
 {
-    type Item = T;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        let last_item = self.last.as_ref()?;
-        let mut next = loop {
-            let curr = self.inner.next();
-            if let Some(curr_item) = &curr {
-                if (self.key)(last_item) != (self.key)(curr_item) {
-                    break curr;
-                }
-            } else {
-                break None;
-            }
-        };
-
-        swap(&mut self.last, &mut next);
-        next
-    }
-
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        if self.last.is_some() {
-            // If we have a last item stored, the iterator can yield at most
-            // as many items at the inner iterator plus the stored one. Yet we
-            // can only guarantee that the iterator yields at least one more item
-            // since all other items in the inner iterator might be duplicates.
-            let (_, max) = self.inner.size_hint();
-            (1, max.and_then(|k| k.checked_add(1)))
-        } else {
-            // If the last item we got from the inner iterator is `None`,
-            // the iterator is empty.
-            (0, Some(0))
-        }
-    }
 }

library/core/src/iter/adapters/mod.rs

@@ -68,7 +68,7 @@ pub use self::zip::TrustedRandomAccessNoCoerce;
 pub use self::zip::zip;
 
 #[unstable(feature = "iter_dedup", reason = "recently added", issue = "83748")]
-pub use self::dedup::{Dedup, DedupBy, DedupByKey};
+pub use self::dedup::{Dedup, ByKey, ByPartialEq};
 
 /// This trait provides transitive access to source-stage in an interator-adapter pipeline
 /// under the conditions that

library/core/src/iter/mod.rs

@@ -424,7 +424,7 @@ pub use self::adapters::{
     Skip, SkipWhile, Take, TakeWhile, Zip,
 };
 #[unstable(feature = "iter_dedup", reason = "recently added", issue = "83748")]
-pub use self::adapters::{Dedup, DedupBy, DedupByKey};
+pub use self::adapters::{Dedup, ByKey, ByPartialEq};
 #[unstable(feature = "iter_intersperse", reason = "recently added", issue = "79524")]
 pub use self::adapters::{Intersperse, IntersperseWith};
 

library/core/src/iter/traits/iterator.rs

@@ -6,7 +6,7 @@ use super::super::try_process;
 use super::super::ByRefSized;
 use super::super::TrustedRandomAccessNoCoerce;
 use super::super::{ArrayChunks, Chain, Cloned, Copied, Cycle, Enumerate, Filter, FilterMap, Fuse};
-use super::super::{Dedup, DedupBy, DedupByKey};
+use super::super::{Dedup, ByKey, ByPartialEq};
 use super::super::{FlatMap, Flatten};
 use super::super::{FromIterator, Intersperse, IntersperseWith, Product, Sum, Zip};
 use super::super::{
@@ -1715,12 +1715,12 @@ pub trait Iterator {
     /// ```
     #[unstable(feature = "iter_dedup", reason = "recently added", issue = "83748")]
     #[inline]
-    fn dedup(self) -> Dedup<Self, Self::Item>
+    fn dedup(self) -> Dedup<Self, ByPartialEq, Self::Item>
     where
         Self: Sized,
         Self::Item: PartialEq,
     {
-        Dedup::new(self)
+        Dedup::new(self, ByPartialEq::new())
     }
 
     /// Removes all but the first of consecutive elements in the iterator satisfying a given equality
@@ -1751,12 +1751,12 @@ pub trait Iterator {
     /// ```
     #[unstable(feature = "iter_dedup", reason = "recently added", issue = "83748")]
     #[inline]
-    fn dedup_by<F>(self, same_bucket: F) -> DedupBy<Self, F, Self::Item>
+    fn dedup_by<F>(self, same_bucket: F) -> Dedup<Self, F, Self::Item>
     where
         Self: Sized,
         F: FnMut(&Self::Item, &Self::Item) -> bool,
     {
-        DedupBy::new(self, same_bucket)
+        Dedup::new(self, same_bucket)
     }
 
     /// Removes all but the first of consecutive elements in the iterator that
@@ -1784,13 +1784,13 @@ pub trait Iterator {
     /// ```
     #[unstable(feature = "iter_dedup", reason = "recently added", issue = "83748")]
     #[inline]
-    fn dedup_by_key<F, K>(self, key: F) -> DedupByKey<Self, F, Self::Item>
+    fn dedup_by_key<F, K>(self, key: F) -> Dedup<Self, ByKey<F>, Self::Item>
     where
         Self: Sized,
         F: FnMut(&Self::Item) -> K,
         K: PartialEq,
     {
-        DedupByKey::new(self, key)
+        Dedup::new(self, ByKey::new(key))
     }
 
     /// Borrows an iterator, rather than consuming it.