changed name to take_while_inclusive and reversed semantics back to match take_while

Author: Erik Rhodes

src/lib.rs

@@ -146,7 +146,7 @@ pub mod structs {
     pub use crate::repeatn::RepeatN;
     #[allow(deprecated)]
     pub use crate::sources::{RepeatCall, Unfold, Iterate};
-    pub use crate::take_until::TakeUntil;
+    pub use crate::take_while_inclusive::TakeWhileInclusive;
     #[cfg(feature = "use_alloc")]
     pub use crate::tee::Tee;
     pub use crate::tuple_impl::{TupleBuffer, TupleWindows, CircularTupleWindows, Tuples};
@@ -234,7 +234,7 @@ mod rciter_impl;
 mod repeatn;
 mod size_hint;
 mod sources;
-mod take_until;
+mod take_while_inclusive;
 #[cfg(feature = "use_alloc")]
 mod tee;
 mod tuple_impl;
@@ -1392,20 +1392,15 @@ pub trait Itertools : Iterator {
     }
 
     /// Returns an iterator adaptor that consumes elements while the given
-    /// predicate is `false`, *including* the element for which the predicate
-    /// first returned `true`.
+    /// predicate is `true`, *including* the element for which the predicate
+    /// first returned `false`.
     ///
     /// The [`.take_while()`][std::iter::Iterator::take_while] adaptor is useful
     /// when you want items satisfying a predicate, but to know when to stop
     /// taking elements, we have to consume that last element that doesn't
     /// satisfy the predicate. This adaptor includes that element where
     /// [`.take_while()`][std::iter::Iterator::take_while] would drop it.
     ///
-    /// Note that the semantics of this predicate are reversed from
-    /// [`.take_while()`][std::iter::Iterator::take_while], i.e. this function's
-    /// predicate yields elements when it evaluates to `false` instead of when
-    /// it evaluates to `true`.
-    ///
     /// The [`.take_while_ref()`][crate::Itertools::take_while_ref] adaptor
     /// serves a similar purpose, but this adaptor doesn't require [`Clone`]ing
     /// the underlying elements.
@@ -1414,7 +1409,10 @@ pub trait Itertools : Iterator {
     /// # use itertools::Itertools;
     ///
     /// let items = vec![1, 2, 3, 4, 5];
-    /// let filtered: Vec<_> = items.into_iter().take_until(|&n| n % 3 == 0).collect();
+    /// let filtered: Vec<_> = items
+    ///     .into_iter()
+    ///     .take_while_inclusive(|&n| n % 3 != 0)
+    ///     .collect();
     ///
     /// assert_eq!(filtered, vec![1, 2, 3]);
     /// ```
@@ -1426,7 +1424,7 @@ pub trait Itertools : Iterator {
     /// let take_until_result: Vec<_> = items
     ///     .clone()
     ///     .into_iter()
-    ///     .take_until(|&n| n % 3 == 0)
+    ///     .take_while_inclusive(|&n| n % 3 != 0)
     ///     .collect();
     /// let take_while_result: Vec<_> = items
     ///     .into_iter()
@@ -1448,16 +1446,16 @@ pub trait Itertools : Iterator {
     ///     .collect();
     /// let filtered: Vec<_> = non_clonable_items
     ///     .into_iter()
-    ///     .take_until(|n| n.0 % 3 == 0)
+    ///     .take_while_inclusive(|n| n.0 % 3 != 0)
     ///     .collect();
     /// let expected: Vec<_> = vec![1, 2, 3].into_iter().map(NoCloneImpl).collect();
     /// assert_eq!(filtered, expected);
-    fn take_until<F>(&mut self, accept: F) -> TakeUntil<Self, F>
+    fn take_while_inclusive<F>(&mut self, accept: F) -> TakeWhileInclusive<Self, F>
     where
         Self: Sized,
         F: FnMut(&Self::Item) -> bool,
     {
-        take_until::TakeUntil::new(self, accept)
+        take_while_inclusive::TakeWhileInclusive::new(self, accept)
     }
 
     /// Return an iterator adaptor that filters `Option<A>` iterator elements

src/take_until.rs src/take_while_inclusive.rssrc/take_until.rs renamed to src/take_while_inclusive.rs

@@ -1,35 +1,35 @@
 use core::iter::FusedIterator;
 use std::fmt;
 
-/// An iterator adaptor that consumes elements while the given predicate is false, including the
-/// element for which the predicate first returned true.
+/// An iterator adaptor that consumes elements while the given predicate is `true`, including the
+/// element for which the predicate first returned `false`.
 ///
-/// See [`.take_until()`](crate::Itertools::take_until) for more information.
+/// See [`.take_while_inclusive()`](crate::Itertools::take_while_inclusive) for more information.
 #[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
-pub struct TakeUntil<'a, I: 'a, F> {
+pub struct TakeWhileInclusive<'a, I: 'a, F> {
     iter: &'a mut I,
     f: F,
     done: bool,
 }
 
-impl<'a, I, F> TakeUntil<'a, I, F>
+impl<'a, I, F> TakeWhileInclusive<'a, I, F>
 where
     I: Iterator,
     F: FnMut(&I::Item) -> bool,
 {
-    /// Create a new [`TakeUntil`] from an iterator and a predicate.
+    /// Create a new [`TakeWhileInclusive`] from an iterator and a predicate.
     pub fn new(iter: &'a mut I, f: F) -> Self {
         Self { iter, f, done: false}
     }
 }
 
-impl<'a, I, F> fmt::Debug for TakeUntil<'a, I, F>
+impl<'a, I, F> fmt::Debug for TakeWhileInclusive<'a, I, F>
     where I: Iterator + fmt::Debug,
 {
-    debug_fmt_fields!(TakeUntil, iter);
+    debug_fmt_fields!(TakeWhileInclusive, iter);
 }
 
-impl<'a, I, F> Iterator for TakeUntil<'a, I, F>
+impl<'a, I, F> Iterator for TakeWhileInclusive<'a, I, F>
 where
     I: Iterator,
     F: FnMut(&I::Item) -> bool
@@ -41,7 +41,7 @@ where
             None
         } else {
             self.iter.next().map(|item| {
-                if (self.f)(&item) {
+                if !(self.f)(&item) {
                     self.done = true;
                 }
                 item
@@ -58,7 +58,7 @@ where
     }
 }
 
-impl<I, F> FusedIterator for TakeUntil<'_, I, F>
+impl<I, F> FusedIterator for TakeWhileInclusive<'_, I, F>
 where
     I: Iterator,
     F: FnMut(&I::Item) -> bool