Add "nightly" feature that impls TrustedLen and a few more methods for iterators

Author: yotamofek

Cargo.toml

@@ -24,6 +24,7 @@ serde = { version = "1.0.95", optional = true, default-features = false, feature
 default = ["std"]
 std = []
 use_std = ["std"] # deprecated alias
+nightly = []
 
 [dev-dependencies]
 serde_json = "1.0.0"

src/iterator.rs

@@ -130,6 +130,21 @@ where
     {
         for_both!(self, inner => inner.position(predicate))
     }
+
+    #[cfg(feature = "nightly")]
+    fn advance_by(&mut self, n: usize) -> Result<(), core::num::NonZeroUsize> {
+        for_both!(self, inner => inner.advance_by(n))
+    }
+
+    #[cfg(feature = "nightly")]
+    fn try_fold<B, F, T>(&mut self, init: B, f: F) -> T
+    where
+        Self: Sized,
+        F: FnMut(B, Self::Item) -> T,
+        T: core::ops::Try<Output = B>,
+    {
+        for_both!(self, inner => inner.try_fold(init, f))
+    }
 }
 
 impl<L, R> DoubleEndedIterator for Either<L, R>
@@ -158,6 +173,21 @@ where
     {
         for_both!(self, inner => inner.rfind(predicate))
     }
+
+    #[cfg(feature = "nightly")]
+    fn advance_back_by(&mut self, n: usize) -> Result<(), core::num::NonZeroUsize> {
+        for_both!(self, ref mut inner => inner.advance_back_by(n))
+    }
+
+    #[cfg(feature = "nightly")]
+    fn try_rfold<B, F, T>(&mut self, init: B, f: F) -> T
+    where
+        Self: Sized,
+        F: FnMut(B, Self::Item) -> T,
+        T: core::ops::Try<Output = B>,
+    {
+        for_both!(self, inner => inner.try_fold(init, f))
+    }
 }
 
 impl<L, R> ExactSizeIterator for Either<L, R>
@@ -170,6 +200,14 @@ where
     }
 }
 
+#[cfg(feature = "nightly")]
+unsafe impl<L, R> iter::TrustedLen for Either<L, R>
+where
+    L: iter::TrustedLen,
+    R: iter::TrustedLen<Item = L::Item>,
+{
+}
+
 impl<L, R> iter::FusedIterator for Either<L, R>
 where
     L: iter::FusedIterator,
@@ -267,6 +305,21 @@ where
     {
         wrap_either!(&mut self.inner => .position(predicate))
     }
+
+    #[cfg(feature = "nightly")]
+    fn advance_by(&mut self, n: usize) -> Result<(), core::num::NonZeroUsize> {
+        for_both!(self.inner, ref mut inner => inner.advance_by(n))
+    }
+
+    #[cfg(feature = "nightly")]
+    fn try_fold<B, F, T>(&mut self, init: B, f: F) -> T
+    where
+        Self: Sized,
+        F: FnMut(B, Self::Item) -> T,
+        T: core::ops::Try<Output = B>,
+    {
+        wrap_either!(&mut self.inner => .try_fold(init, f))
+    }
 }
 
 impl<L, R> DoubleEndedIterator for IterEither<L, R>
@@ -295,6 +348,21 @@ where
     {
         wrap_either!(&mut self.inner => .rfind(predicate))
     }
+
+    #[cfg(feature = "nightly")]
+    fn advance_back_by(&mut self, n: usize) -> Result<(), core::num::NonZeroUsize> {
+        for_both!(self.inner, ref mut inner => inner.advance_back_by(n))
+    }
+
+    #[cfg(feature = "nightly")]
+    fn try_rfold<B, F, T>(&mut self, init: B, f: F) -> T
+    where
+        Self: Sized,
+        F: FnMut(B, Self::Item) -> T,
+        T: core::ops::Try<Output = B>,
+    {
+        wrap_either!(&mut self.inner => .try_rfold(init, f))
+    }
 }
 
 impl<L, R> ExactSizeIterator for IterEither<L, R>
@@ -307,6 +375,14 @@ where
     }
 }
 
+#[cfg(feature = "nightly")]
+unsafe impl<L, R> iter::TrustedLen for IterEither<L, R>
+where
+    L: iter::TrustedLen,
+    R: iter::TrustedLen,
+{
+}
+
 impl<L, R> iter::FusedIterator for IterEither<L, R>
 where
     L: iter::FusedIterator,

src/lib.rs

@@ -11,7 +11,15 @@
 //! * `"serde"`
 //!   Disabled by default. Enable to `#[derive(Serialize, Deserialize)]` for `Either`
 //!
+//! * `"nightly"`
+//!   Disabled by default. Enable to use nightly-only features for `Iterator` implementations.
+//!   This feature should be considered unstable and may break at any time.
+//!
 
+#![cfg_attr(
+    feature = "nightly",
+    feature(iter_advance_by, try_trait_v2, trusted_len)
+)]
 #![doc(html_root_url = "https://docs.rs/either/1/")]
 #![no_std]