Go back to separate iterators

slerpyyy · slerpyyy · commit a822aad9c7ff · 2022-08-22T01:17:39.000+02:00
diff --git a/library/core/src/iter/adapters/dedup.rs b/library/core/src/iter/adapters/dedup.rs
@@ -2,127 +2,195 @@
 
 use crate::iter::{InPlaceIterable, SourceIter};
 
-/// A wrapper type around a key function.
-///
-/// This struct acts like a function which given a key function returns true
-/// if and only if both arguments evaluate to the same key.
+/// An iterator that removes all but the first of consecutive elements in a
+/// given iterator according to the [`PartialEq`] trait implementation.
 ///
-/// This `struct` is created by [`Iterator::dedup_by_key`].
+/// This `struct` is created by [`Iterator::dedup`].
 /// See its documentation for more.
 ///
-/// [`Iterator::dedup_by_key`]: Iterator::dedup_by_key
-#[derive(Debug, Clone, Copy)]
-pub struct ByKey<F> {
-    key: F,
+/// [`Iterator::dedup`]: Iterator::dedup
+#[derive(Debug, Clone)]
+pub struct Dedup<I>
+where
+    I: Iterator,
+{
+    inner: I,
+    last: Option<Option<I::Item>>,
 }
 
-impl<F> ByKey<F> {
+impl<I> Dedup<I>
+where
+    I: Iterator,
+{
     #[inline]
-    pub(crate) fn new(key: F) -> Self {
-        Self { key }
+    pub(crate) fn new(inner: I) -> Self {
+        Self { inner, last: None }
     }
 }
 
-impl<F, T, K> FnOnce<(&T, &T)> for ByKey<F>
+impl<I> Iterator for Dedup<I>
 where
-    F: FnMut(&T) -> K,
-    K: PartialEq,
+    I: Iterator,
+    I::Item: PartialEq,
 {
-    type Output = bool;
+    type Item = I::Item;
+
     #[inline]
-    extern "rust-call" fn call_once(mut self, args: (&T, &T)) -> Self::Output {
-        (self.key)(args.0) == (self.key)(args.1)
+    fn next(&mut self) -> Option<Self::Item> {
+        let Self { inner, last } = self;
+        let last = last.get_or_insert_with(|| inner.next());
+        let last_item = last.as_ref()?;
+        let next = inner.find(|next_item| next_item != last_item);
+        crate::mem::replace(last, next)
+    }
+
+    #[inline]
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        let min = matches!(self.last, Some(Some(_))).into();
+        let max = self.inner.size_hint().1.map(|max| max + min);
+        (min, max)
     }
 }
 
-impl<F, T, K> FnMut<(&T, &T)> for ByKey<F>
+#[unstable(issue = "none", feature = "inplace_iteration")]
+unsafe impl<I> SourceIter for Dedup<I>
 where
-    F: FnMut(&T) -> K,
-    K: PartialEq,
+    I: SourceIter + Iterator,
 {
+    type Source = I::Source;
+
     #[inline]
-    extern "rust-call" fn call_mut(&mut self, args: (&T, &T)) -> Self::Output {
-        (self.key)(args.0) == (self.key)(args.1)
+    unsafe fn as_inner(&mut self) -> &mut I::Source {
+        // SAFETY: unsafe function forwarding to unsafe function with the same requirements
+        unsafe { SourceIter::as_inner(&mut self.inner) }
     }
 }
 
-/// 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.
+#[unstable(issue = "none", feature = "inplace_iteration")]
+unsafe impl<I> InPlaceIterable for Dedup<I>
+where
+    I: Iterator,
+    I: InPlaceIterable,
+    I::Item: PartialEq,
+{
+}
+
+/// 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`].
+/// This `struct` is created by [`Iterator::dedup_by`].
 /// See its documentation for more.
 ///
-/// [`Iterator::dedup`]: Iterator::dedup
-#[derive(Debug, Clone, Copy)]
-#[non_exhaustive]
-pub struct ByPartialEq;
+/// [`Iterator::dedup_by`]: Iterator::dedup_by
+#[derive(Debug, Clone)]
+pub struct DedupBy<I, F>
+where
+    I: Iterator,
+{
+    inner: I,
+    same_bucket: F,
+    last: Option<Option<I::Item>>,
+}
 
-impl ByPartialEq {
+impl<I, F> DedupBy<I, F>
+where
+    I: Iterator,
+{
     #[inline]
-    pub(crate) fn new() -> Self {
-        Self
+    pub(crate) fn new(inner: I, same_bucket: F) -> Self {
+        Self { inner, same_bucket, last: None }
     }
 }
 
-impl<T: PartialEq> FnOnce<(&T, &T)> for ByPartialEq {
-    type Output = bool;
+impl<I, F> Iterator for DedupBy<I, F>
+where
+    I: Iterator,
+    F: FnMut(&I::Item, &I::Item) -> bool,
+{
+    type Item = I::Item;
+
+    #[inline]
+    fn next(&mut self) -> Option<Self::Item> {
+        let Self { inner, last, same_bucket } = self;
+        let last = last.get_or_insert_with(|| inner.next());
+        let last_item = last.as_ref()?;
+        let next = inner.find(|next_item| !(same_bucket)(next_item, last_item));
+        crate::mem::replace(last, next)
+    }
+
     #[inline]
-    extern "rust-call" fn call_once(self, args: (&T, &T)) -> Self::Output {
-        args.0 == args.1
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        let min = matches!(self.last, Some(Some(_))).into();
+        let max = self.inner.size_hint().1.map(|max| max + min);
+        (min, max)
     }
 }
 
-impl<T: PartialEq> FnMut<(&T, &T)> for ByPartialEq {
+#[unstable(issue = "none", feature = "inplace_iteration")]
+unsafe impl<I, F> SourceIter for DedupBy<I, F>
+where
+    I: SourceIter + Iterator,
+{
+    type Source = I::Source;
+
     #[inline]
-    extern "rust-call" fn call_mut(&mut self, args: (&T, &T)) -> Self::Output {
-        args.0 == args.1
+    unsafe fn as_inner(&mut self) -> &mut I::Source {
+        // SAFETY: unsafe function forwarding to unsafe function with the same requirements
+        unsafe { SourceIter::as_inner(&mut self.inner) }
     }
 }
 
+#[unstable(issue = "none", feature = "inplace_iteration")]
+unsafe impl<I, F> InPlaceIterable for DedupBy<I, F>
+where
+    I: InPlaceIterable,
+    F: FnMut(&I::Item, &I::Item) -> bool,
+{
+}
+
 /// An iterator that removes all but the first of consecutive elements in a
-/// given iterator satisfying a given equality relation.
+/// given iterator that resolve to the same key.
 ///
-/// This `struct` is created by [`Iterator::dedup`], [`Iterator::dedup_by`]
-/// and [`Iterator::dedup_by_key`]. See its documentation for more.
+/// This `struct` is created by  [`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
 #[derive(Debug, Clone)]
-pub struct Dedup<I, F>
+pub struct DedupByKey<I, F, K>
 where
     I: Iterator,
+    F: FnMut(&I::Item) -> K,
 {
     inner: I,
-    same_bucket: F,
+    key: F,
     last: Option<Option<I::Item>>,
 }
 
-impl<I, F> Dedup<I, F>
+impl<I, F, K> DedupByKey<I, F, K>
 where
     I: Iterator,
+    F: FnMut(&I::Item) -> K,
 {
     #[inline]
-    pub(crate) fn new(inner: I, same_bucket: F) -> Self {
-        Self { inner, same_bucket, last: None }
+    pub(crate) fn new(inner: I, key: F) -> Self {
+        Self { inner, key, last: None }
     }
 }
 
-impl<I, F> Iterator for Dedup<I, F>
+impl<I, F, K> Iterator for DedupByKey<I, F, K>
 where
     I: Iterator,
-    F: FnMut(&I::Item, &I::Item) -> bool,
+    F: FnMut(&I::Item) -> K,
+    K: PartialEq,
 {
     type Item = I::Item;
 
     #[inline]
     fn next(&mut self) -> Option<Self::Item> {
-        let Self { inner, last, same_bucket } = self;
+        let Self { inner, last, key } = self;
         let last = last.get_or_insert_with(|| inner.next());
         let last_item = last.as_ref()?;
-        let next = inner.find(|next_item| !(same_bucket)(next_item, last_item));
+        let next = inner.find(|next_item| key(next_item) != key(last_item));
         crate::mem::replace(last, next)
     }
 
@@ -135,9 +203,10 @@ where
 }
 
 #[unstable(issue = "none", feature = "inplace_iteration")]
-unsafe impl<I, F> SourceIter for Dedup<I, F>
+unsafe impl<I, F, K> SourceIter for DedupByKey<I, F, K>
 where
     I: SourceIter + Iterator,
+    F: FnMut(&I::Item) -> K,
 {
     type Source = I::Source;
 
@@ -149,9 +218,10 @@ where
 }
 
 #[unstable(issue = "none", feature = "inplace_iteration")]
-unsafe impl<I, F> InPlaceIterable for Dedup<I, F>
+unsafe impl<I, F, K> InPlaceIterable for DedupByKey<I, F, K>
 where
     I: InPlaceIterable,
-    F: FnMut(&I::Item, &I::Item) -> bool,
+    F: FnMut(&I::Item) -> K,
+    K: PartialEq,
 {
 }
diff --git a/library/core/src/iter/adapters/mod.rs b/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::{ByKey, ByPartialEq, Dedup};
+pub use self::dedup::{Dedup, DedupBy, DedupByKey};
 
 /// This trait provides transitive access to source-stage in an interator-adapter pipeline
 /// under the conditions that
diff --git a/library/core/src/iter/mod.rs b/library/core/src/iter/mod.rs
@@ -418,13 +418,13 @@ pub use self::adapters::StepBy;
 pub use self::adapters::TrustedRandomAccess;
 #[unstable(feature = "trusted_random_access", issue = "none")]
 pub use self::adapters::TrustedRandomAccessNoCoerce;
-#[unstable(feature = "iter_dedup", reason = "recently added", issue = "83748")]
-pub use self::adapters::{ByKey, ByPartialEq, Dedup};
 #[stable(feature = "rust1", since = "1.0.0")]
 pub use self::adapters::{
     Chain, Cycle, Enumerate, Filter, FilterMap, FlatMap, Fuse, Inspect, Map, Peekable, Rev, Scan,
     Skip, SkipWhile, Take, TakeWhile, Zip,
 };
+#[unstable(feature = "iter_dedup", reason = "recently added", issue = "83748")]
+pub use self::adapters::{Dedup, DedupBy, DedupByKey};
 #[unstable(feature = "iter_intersperse", reason = "recently added", issue = "79524")]
 pub use self::adapters::{Intersperse, IntersperseWith};
 
diff --git a/library/core/src/iter/traits/iterator.rs b/library/core/src/iter/traits/iterator.rs
@@ -5,8 +5,8 @@ use crate::ops::{ChangeOutputType, ControlFlow, FromResidual, Residual, Try};
 use super::super::try_process;
 use super::super::ByRefSized;
 use super::super::TrustedRandomAccessNoCoerce;
-use super::super::{Chain, Cloned, Copied, Cycle, Enumerate, Filter, FilterMap, Fuse};
-use super::super::{ByKey, ByPartialEq, Dedup};
+use super::super::{ArrayChunks, Chain, Cloned, Copied, Cycle, Enumerate, Filter, FilterMap, Fuse};
+use super::super::{Dedup, DedupBy, DedupByKey};
 use super::super::{FlatMap, Flatten};
 use super::super::{FromIterator, Intersperse, IntersperseWith, Product, Sum, Zip};
 use super::super::{
@@ -1726,12 +1726,12 @@ pub trait Iterator {
     /// ```
     #[unstable(feature = "iter_dedup", reason = "recently added", issue = "83748")]
     #[inline]
-    fn dedup(self) -> Dedup<Self, ByPartialEq>
+    fn dedup(self) -> Dedup<Self>
     where
         Self: Sized,
         Self::Item: PartialEq,
     {
-        Dedup::new(self, ByPartialEq::new())
+        Dedup::new(self)
     }
 
     /// Removes all but the first of consecutive elements in the iterator
@@ -1773,7 +1773,7 @@ pub trait Iterator {
     /// ```
     #[unstable(feature = "iter_dedup", reason = "recently added", issue = "83748")]
     #[inline]
-    fn dedup_by<F>(self, same_bucket: F) -> Dedup<Self, F>
+    fn dedup_by<F>(self, same_bucket: F) -> DedupBy<Self, F>
     where
         Self: Sized,
         F: FnMut(&Self::Item, &Self::Item) -> bool,
@@ -1817,13 +1817,13 @@ pub trait Iterator {
     /// ```
     #[unstable(feature = "iter_dedup", reason = "recently added", issue = "83748")]
     #[inline]
-    fn dedup_by_key<F, K>(self, key: F) -> Dedup<Self, ByKey<F>>
+    fn dedup_by_key<F, K>(self, key: F) -> DedupByKey<Self, F, K>
     where
         Self: Sized,
         F: FnMut(&Self::Item) -> K,
         K: PartialEq,
     {
-        Dedup::new(self, ByKey::new(key))
+        Dedup::new(self, key)
     }
 
     /// Borrows an iterator, rather than consuming it.
