//! Extra iterator adaptors, functions and macros. //! //! To extend [`Iterator`] with methods in this crate, import //! the [`Itertools`] trait: //! //! ``` //! use itertools::Itertools; //! ``` //! //! Now, new methods like [`interleave`](Itertools::interleave) //! are available on all iterators: //! //! ``` //! use itertools::Itertools; //! //! let it = (1..3).interleave(vec![-1, -2]); //! itertools::assert_equal(it, vec![1, -1, 2, -2]); //! ``` //! //! Most iterator methods are also provided as functions (with the benefit //! that they convert parameters using [`IntoIterator`]): //! //! ``` //! use itertools::interleave; //! //! for elt in interleave(&[1, 2, 3], &[2, 3, 4]) { //! /* loop body */ //! } //! ``` //! //! ## Crate Features //! //! - `use_std` //! - Enabled by default. //! - Disable to compile itertools using `#![no_std]`. This disables //! any items that depend on collections (like `group_by`, `unique`, //! `kmerge`, `join` and many more). //! //! ## Rust Version //! //! This version of itertools requires Rust 1.32 or later. #![doc(html_root_url="https://docs.rs/itertools/0.8/")]
#[cfg(not(feature = "use_std"))] externcrate core as std;
#[cfg(feature = "use_alloc")] externcrate alloc;
#[cfg(feature = "use_alloc")] use alloc::{
string::String,
vec::Vec,
};
pubuse either::Either;
use core::borrow::Borrow; #[cfg(feature = "use_std")] use std::collections::HashMap; use std::iter::{IntoIterator, once}; use std::cmp::Ordering; use std::fmt; #[cfg(feature = "use_std")] use std::collections::HashSet; #[cfg(feature = "use_std")] use std::hash::Hash; #[cfg(feature = "use_alloc")] use std::fmt::Write; #[cfg(feature = "use_alloc")] type VecIntoIter<T> = alloc::vec::IntoIter<T>; #[cfg(feature = "use_alloc")] use std::iter::FromIterator;
#[macro_use] mod impl_macros;
// for compatibility with no std and macros #[doc(hidden)] pubuse std::iter as __std_iter;
/// Traits helpful for using certain `Itertools` methods in generic contexts. pubmod traits { pubusecrate::tuple_impl::HomogeneousTuple;
}
#[allow(deprecated)] pubusecrate::structs::*; pubusecrate::concat_impl::concat; pubusecrate::cons_tuples_impl::cons_tuples; pubusecrate::diff::diff_with; pubusecrate::diff::Diff; #[cfg(feature = "use_alloc")] pubusecrate::kmerge_impl::{kmerge_by}; pubusecrate::minmax::MinMaxResult; pubusecrate::peeking_take_while::PeekingNext; pubusecrate::process_results_impl::process_results; pubusecrate::repeatn::repeat_n; #[allow(deprecated)] pubusecrate::sources::{repeat_call, unfold, iterate}; pubusecrate::with_position::Position; pubusecrate::unziptuple::{multiunzip, MultiUnzip}; pubusecrate::ziptuple::multizip; mod adaptors; mod either_or_both; pubusecrate::either_or_both::EitherOrBoth; #[doc(hidden)] pubmod free; #[doc(inline)] pubusecrate::free::*; mod concat_impl; mod cons_tuples_impl; #[cfg(feature = "use_alloc")] mod combinations; #[cfg(feature = "use_alloc")] mod combinations_with_replacement; mod exactly_one_err; mod diff; mod flatten_ok; #[cfg(feature = "use_std")] mod extrema_set; mod format; #[cfg(feature = "use_std")] mod grouping_map; #[cfg(feature = "use_alloc")] mod group_map; #[cfg(feature = "use_alloc")] mod groupbylazy; mod intersperse; #[cfg(feature = "use_alloc")] mod k_smallest; #[cfg(feature = "use_alloc")] mod kmerge_impl; #[cfg(feature = "use_alloc")] mod lazy_buffer; mod merge_join; mod minmax; #[cfg(feature = "use_alloc")] mod multipeek_impl; mod pad_tail; #[cfg(feature = "use_alloc")] mod peek_nth; mod peeking_take_while; #[cfg(feature = "use_alloc")] mod permutations; #[cfg(feature = "use_alloc")] mod powerset; mod process_results_impl; #[cfg(feature = "use_alloc")] mod put_back_n_impl; #[cfg(feature = "use_alloc")] mod rciter_impl; mod repeatn; mod size_hint; mod sources; #[cfg(feature = "use_alloc")] mod tee; mod tuple_impl; #[cfg(feature = "use_std")] mod duplicates_impl; #[cfg(feature = "use_std")] mod unique_impl; mod unziptuple; mod with_position; mod zip_eq_impl; mod zip_longest; mod ziptuple;
#[macro_export] /// Create an iterator over the “cartesian product” of iterators. /// /// Iterator element type is like `(A, B, ..., E)` if formed /// from iterators `(I, J, ..., M)` with element types `I::Item = A`, `J::Item = B`, etc. /// /// ``` /// # use itertools::iproduct; /// # /// # fn main() { /// // Iterate over the coordinates of a 4 x 4 x 4 grid /// // from (0, 0, 0), (0, 0, 1), .., (0, 1, 0), (0, 1, 1), .. etc until (3, 3, 3) /// for (i, j, k) in iproduct!(0..4, 0..4, 0..4) { /// // .. /// } /// # } /// ```
macro_rules! iproduct {
(@flatten $I:expr,) => (
$I
);
(@flatten $I:expr, $J:expr, $($K:expr,)*) => (
$crate::iproduct!(@flatten $crate::cons_tuples($crate::iproduct!($I, $J)), $($K,)*)
);
($I:expr) => (
$crate::__std_iter::IntoIterator::into_iter($I)
);
($I:expr, $J:expr) => (
$crate::Itertools::cartesian_product($crate::iproduct!($I), $crate::iproduct!($J))
);
($I:expr, $J:expr, $($K:expr),+) => (
$crate::iproduct!(@flatten $crate::iproduct!($I, $J), $($K,)+)
);
}
#[macro_export] /// Create an iterator running multiple iterators in lockstep. /// /// The `izip!` iterator yields elements until any subiterator /// returns `None`. /// /// This is a version of the standard ``.zip()`` that's supporting more than /// two iterators. The iterator element type is a tuple with one element /// from each of the input iterators. Just like ``.zip()``, the iteration stops /// when the shortest of the inputs reaches its end. /// /// **Note:** The result of this macro is in the general case an iterator /// composed of repeated `.zip()` and a `.map()`; it has an anonymous type. /// The special cases of one and two arguments produce the equivalent of /// `$a.into_iter()` and `$a.into_iter().zip($b)` respectively. /// /// Prefer this macro `izip!()` over [`multizip`] for the performance benefits /// of using the standard library `.zip()`. /// /// ``` /// # use itertools::izip; /// # /// # fn main() { /// /// // iterate over three sequences side-by-side /// let mut results = [0, 0, 0, 0]; /// let inputs = [3, 7, 9, 6]; /// /// for (r, index, input) in izip!(&mut results, 0..10, &inputs) { /// *r = index * 10 + input; /// } /// /// assert_eq!(results, [0 + 3, 10 + 7, 29, 36]); /// # } /// ```
macro_rules! izip { // @closure creates a tuple-flattening closure for .map() call. usage: // @closure partial_pattern => partial_tuple , rest , of , iterators // eg. izip!( @closure ((a, b), c) => (a, b, c) , dd , ee )
( @closure $p:pat => $tup:expr ) => {
|$p| $tup
};
// The "b" identifier is a different identifier on each recursion level thanks to hygiene.
( @closure $p:pat => ( $($tup:tt)* ) , $_iter:expr $( , $tail:expr )* ) => {
$crate::izip!(@closure ($p, b) => ( $($tup)*, b ) $( , $tail )*)
};
#[macro_export] /// [Chain][`chain`] zero or more iterators together into one sequence. /// /// The comma-separated arguments must implement [`IntoIterator`]. /// The final argument may be followed by a trailing comma. /// /// [`chain`]: Iterator::chain /// /// # Examples /// /// Empty invocations of `chain!` expand to an invocation of [`std::iter::empty`]: /// ``` /// use std::iter; /// use itertools::chain; /// /// let _: iter::Empty<()> = chain!(); /// let _: iter::Empty<i8> = chain!(); /// ``` /// /// Invocations of `chain!` with one argument expand to [`arg.into_iter()`](IntoIterator): /// ``` /// use std::{ops::Range, slice}; /// use itertools::chain; /// let _: <Range<_> as IntoIterator>::IntoIter = chain!((2..6),); // trailing comma optional! /// let _: <&[_] as IntoIterator>::IntoIter = chain!(&[2, 3, 4]); /// ``` /// /// Invocations of `chain!` with multiple arguments [`.into_iter()`](IntoIterator) each /// argument, and then [`chain`] them together: /// ``` /// use std::{iter::*, ops::Range, slice}; /// use itertools::{assert_equal, chain}; /// /// // e.g., this: /// let with_macro: Chain<Chain<Once<_>, Take<Repeat<_>>>, slice::Iter<_>> = /// chain![once(&0), repeat(&1).take(2), &[2, 3, 5],]; /// /// // ...is equivalent to this: /// let with_method: Chain<Chain<Once<_>, Take<Repeat<_>>>, slice::Iter<_>> = /// once(&0) /// .chain(repeat(&1).take(2)) /// .chain(&[2, 3, 5]); /// /// assert_equal(with_macro, with_method); /// ```
macro_rules! chain {
() => {
core::iter::empty()
};
($first:expr $(, $rest:expr )* $(,)?) => {
{ let iter = core::iter::IntoIterator::into_iter($first);
$( let iter =
core::iter::Iterator::chain(
iter,
core::iter::IntoIterator::into_iter($rest));
)*
iter
}
};
}
/// An [`Iterator`] blanket implementation that provides extra adaptors and /// methods. /// /// This trait defines a number of methods. They are divided into two groups: /// /// * *Adaptors* take an iterator and parameter as input, and return /// a new iterator value. These are listed first in the trait. An example /// of an adaptor is [`.interleave()`](Itertools::interleave) /// /// * *Regular methods* are those that don't return iterators and instead /// return a regular value of some other kind. /// [`.next_tuple()`](Itertools::next_tuple) is an example and the first regular /// method in the list. pubtrait Itertools : Iterator { // adaptors
/// Alternate elements from two iterators until both have run out. /// /// Iterator element type is `Self::Item`. /// /// This iterator is *fused*. /// /// ``` /// use itertools::Itertools; /// /// let it = (1..7).interleave(vec![-1, -2]); /// itertools::assert_equal(it, vec![1, -1, 2, -2, 3, 4, 5, 6]); /// ``` fn interleave<J>(self, other: J) -> Interleave<Self, J::IntoIter> where J: IntoIterator<Item = Self::Item>, Self: Sized
{
interleave(self, other)
}
/// Alternate elements from two iterators until at least one of them has run /// out. /// /// Iterator element type is `Self::Item`. /// /// ``` /// use itertools::Itertools; /// /// let it = (1..7).interleave_shortest(vec![-1, -2]); /// itertools::assert_equal(it, vec![1, -1, 2, -2, 3]); /// ``` fn interleave_shortest<J>(self, other: J) -> InterleaveShortest<Self, J::IntoIter> where J: IntoIterator<Item = Self::Item>, Self: Sized
{
adaptors::interleave_shortest(self, other.into_iter())
}
/// An iterator adaptor to insert a particular value /// between each element of the adapted iterator. /// /// Iterator element type is `Self::Item`. /// /// This iterator is *fused*. /// /// ``` /// use itertools::Itertools; /// /// itertools::assert_equal((0..3).intersperse(8), vec![0, 8, 1, 8, 2]); /// ``` fn intersperse(self, element: Self::Item) -> Intersperse<Self> whereSelf: Sized, Self::Item: Clone
{
intersperse::intersperse(self, element)
}
/// An iterator adaptor to insert a particular value created by a function /// between each element of the adapted iterator. /// /// Iterator element type is `Self::Item`. /// /// This iterator is *fused*. /// /// ``` /// use itertools::Itertools; /// /// let mut i = 10; /// itertools::assert_equal((0..3).intersperse_with(|| { i -= 1; i }), vec![0, 9, 1, 8, 2]); /// assert_eq!(i, 8); /// ``` fn intersperse_with<F>(self, element: F) -> IntersperseWith<Self, F> whereSelf: Sized,
F: FnMut() -> Self::Item
{
intersperse::intersperse_with(self, element)
}
/// Create an iterator which iterates over both this and the specified /// iterator simultaneously, yielding pairs of two optional elements. /// /// This iterator is *fused*. /// /// As long as neither input iterator is exhausted yet, it yields two values /// via `EitherOrBoth::Both`. /// /// When the parameter iterator is exhausted, it only yields a value from the /// `self` iterator via `EitherOrBoth::Left`. /// /// When the `self` iterator is exhausted, it only yields a value from the /// parameter iterator via `EitherOrBoth::Right`. /// /// When both iterators return `None`, all further invocations of `.next()` /// will return `None`. /// /// Iterator element type is /// [`EitherOrBoth<Self::Item, J::Item>`](EitherOrBoth). /// /// ```rust /// use itertools::EitherOrBoth::{Both, Right}; /// use itertools::Itertools; /// let it = (0..1).zip_longest(1..3); /// itertools::assert_equal(it, vec![Both(0, 1), Right(2)]); /// ``` #[inline] fn zip_longest<J>(self, other: J) -> ZipLongest<Self, J::IntoIter> where J: IntoIterator, Self: Sized
{
zip_longest::zip_longest(self, other.into_iter())
}
/// Create an iterator which iterates over both this and the specified /// iterator simultaneously, yielding pairs of elements. /// /// **Panics** if the iterators reach an end and they are not of equal /// lengths. #[inline] fn zip_eq<J>(self, other: J) -> ZipEq<Self, J::IntoIter> where J: IntoIterator, Self: Sized
{
zip_eq(self, other)
}
/// A “meta iterator adaptor”. Its closure receives a reference to the /// iterator and may pick off as many elements as it likes, to produce the /// next iterator element. /// /// Iterator element type is `B`. /// /// ``` /// use itertools::Itertools; /// /// // An adaptor that gathers elements in pairs /// let pit = (0..4).batching(|it| { /// match it.next() { /// None => None, /// Some(x) => match it.next() { /// None => None, /// Some(y) => Some((x, y)), /// } /// } /// }); /// /// itertools::assert_equal(pit, vec![(0, 1), (2, 3)]); /// ``` /// fn batching<B, F>(self, f: F) -> Batching<Self, F> where F: FnMut(&mutSelf) -> Option<B>, Self: Sized
{
adaptors::batching(self, f)
}
/// Return an *iterable* that can group iterator elements. /// Consecutive elements that map to the same key (“runs”), are assigned /// to the same group. /// /// `GroupBy` is the storage for the lazy grouping operation. /// /// If the groups are consumed in order, or if each group's iterator is /// dropped without keeping it around, then `GroupBy` uses no /// allocations. It needs allocations only if several group iterators /// are alive at the same time. /// /// This type implements [`IntoIterator`] (it is **not** an iterator /// itself), because the group iterators need to borrow from this /// value. It should be stored in a local variable or temporary and /// iterated. /// /// Iterator element type is `(K, Group)`: the group's key and the /// group iterator. /// /// ``` /// use itertools::Itertools; /// /// // group data into runs of larger than zero or not. /// let data = vec![1, 3, -2, -2, 1, 0, 1, 2]; /// // groups: |---->|------>|--------->| /// /// // Note: The `&` is significant here, `GroupBy` is iterable /// // only by reference. You can also call `.into_iter()` explicitly. /// let mut data_grouped = Vec::new(); /// for (key, group) in &data.into_iter().group_by(|elt| *elt >= 0) { /// data_grouped.push((key, group.collect())); /// } /// assert_eq!(data_grouped, vec![(true, vec![1, 3]), (false, vec![-2, -2]), (true, vec![1, 0, 1, 2])]); /// ``` #[cfg(feature = "use_alloc")] fn group_by<K, F>(self, key: F) -> GroupBy<K, Self, F> whereSelf: Sized,
F: FnMut(&Self::Item) -> K,
K: PartialEq,
{
groupbylazy::new(self, key)
}
/// Return an *iterable* that can chunk the iterator. /// /// Yield subiterators (chunks) that each yield a fixed number elements, /// determined by `size`. The last chunk will be shorter if there aren't /// enough elements. /// /// `IntoChunks` is based on `GroupBy`: it is iterable (implements /// `IntoIterator`, **not** `Iterator`), and it only buffers if several /// chunk iterators are alive at the same time. /// /// Iterator element type is `Chunk`, each chunk's iterator. /// /// **Panics** if `size` is 0. /// /// ``` /// use itertools::Itertools; /// /// let data = vec![1, 1, 2, -2, 6, 0, 3, 1]; /// //chunk size=3 |------->|-------->|--->| /// /// // Note: The `&` is significant here, `IntoChunks` is iterable /// // only by reference. You can also call `.into_iter()` explicitly. /// for chunk in &data.into_iter().chunks(3) { /// // Check that the sum of each chunk is 4. /// assert_eq!(4, chunk.sum()); /// } /// ``` #[cfg(feature = "use_alloc")] fn chunks(self, size: usize) -> IntoChunks<Self> whereSelf: Sized,
{
assert!(size != 0);
groupbylazy::new_chunks(self, size)
}
/// Return an iterator over all contiguous windows producing tuples of /// a specific size (up to 12). /// /// `tuple_windows` clones the iterator elements so that they can be /// part of successive windows, this makes it most suited for iterators /// of references and other values that are cheap to copy. /// /// ``` /// use itertools::Itertools; /// let mut v = Vec::new(); /// /// // pairwise iteration /// for (a, b) in (1..5).tuple_windows() { /// v.push((a, b)); /// } /// assert_eq!(v, vec![(1, 2), (2, 3), (3, 4)]); /// /// let mut it = (1..5).tuple_windows(); /// assert_eq!(Some((1, 2, 3)), it.next()); /// assert_eq!(Some((2, 3, 4)), it.next()); /// assert_eq!(None, it.next()); /// /// // this requires a type hint /// let it = (1..5).tuple_windows::<(_, _, _)>(); /// itertools::assert_equal(it, vec![(1, 2, 3), (2, 3, 4)]); /// /// // you can also specify the complete type /// use itertools::TupleWindows; /// use std::ops::Range; /// /// let it: TupleWindows<Range<u32>, (u32, u32, u32)> = (1..5).tuple_windows(); /// itertools::assert_equal(it, vec![(1, 2, 3), (2, 3, 4)]); /// ``` fn tuple_windows<T>(self) -> TupleWindows<Self, T> whereSelf: Sized + Iterator<Item = T::Item>,
T: traits::HomogeneousTuple,
T::Item: Clone
{
tuple_impl::tuple_windows(self)
}
/// Return an iterator over all windows, wrapping back to the first /// elements when the window would otherwise exceed the length of the /// iterator, producing tuples of a specific size (up to 12). /// /// `circular_tuple_windows` clones the iterator elements so that they can be /// part of successive windows, this makes it most suited for iterators /// of references and other values that are cheap to copy. /// /// ``` /// use itertools::Itertools; /// let mut v = Vec::new(); /// for (a, b) in (1..5).circular_tuple_windows() { /// v.push((a, b)); /// } /// assert_eq!(v, vec![(1, 2), (2, 3), (3, 4), (4, 1)]); /// /// let mut it = (1..5).circular_tuple_windows(); /// assert_eq!(Some((1, 2, 3)), it.next()); /// assert_eq!(Some((2, 3, 4)), it.next()); /// assert_eq!(Some((3, 4, 1)), it.next()); /// assert_eq!(Some((4, 1, 2)), it.next()); /// assert_eq!(None, it.next()); /// /// // this requires a type hint /// let it = (1..5).circular_tuple_windows::<(_, _, _)>(); /// itertools::assert_equal(it, vec![(1, 2, 3), (2, 3, 4), (3, 4, 1), (4, 1, 2)]); /// ``` fn circular_tuple_windows<T>(self) -> CircularTupleWindows<Self, T> whereSelf: Sized + Clone + Iterator<Item = T::Item> + ExactSizeIterator,
T: tuple_impl::TupleCollect + Clone,
T::Item: Clone
{
tuple_impl::circular_tuple_windows(self)
} /// Return an iterator that groups the items in tuples of a specific size /// (up to 12). /// /// See also the method [`.next_tuple()`](Itertools::next_tuple). /// /// ``` /// use itertools::Itertools; /// let mut v = Vec::new(); /// for (a, b) in (1..5).tuples() { /// v.push((a, b)); /// } /// assert_eq!(v, vec![(1, 2), (3, 4)]); /// /// let mut it = (1..7).tuples(); /// assert_eq!(Some((1, 2, 3)), it.next()); /// assert_eq!(Some((4, 5, 6)), it.next()); /// assert_eq!(None, it.next()); /// /// // this requires a type hint /// let it = (1..7).tuples::<(_, _, _)>(); /// itertools::assert_equal(it, vec![(1, 2, 3), (4, 5, 6)]); /// /// // you can also specify the complete type /// use itertools::Tuples; /// use std::ops::Range; /// /// let it: Tuples<Range<u32>, (u32, u32, u32)> = (1..7).tuples(); /// itertools::assert_equal(it, vec![(1, 2, 3), (4, 5, 6)]); /// ``` /// /// See also [`Tuples::into_buffer`]. fn tuples<T>(self) -> Tuples<Self, T> whereSelf: Sized + Iterator<Item = T::Item>,
T: traits::HomogeneousTuple
{
tuple_impl::tuples(self)
}
/// Split into an iterator pair that both yield all elements from /// the original iterator. /// /// **Note:** If the iterator is clonable, prefer using that instead /// of using this method. Cloning is likely to be more efficient. /// /// Iterator element type is `Self::Item`. /// /// ``` /// use itertools::Itertools; /// let xs = vec![0, 1, 2, 3]; /// /// let (mut t1, t2) = xs.into_iter().tee(); /// itertools::assert_equal(t1.next(), Some(0)); /// itertools::assert_equal(t2, 0..4); /// itertools::assert_equal(t1, 1..4); /// ``` #[cfg(feature = "use_alloc")] fn tee(self) -> (Tee<Self>, Tee<Self>) whereSelf: Sized, Self::Item: Clone
{
tee::new(self)
}
/// Return an iterator adaptor that steps `n` elements in the base iterator /// for each iteration. /// /// The iterator steps by yielding the next element from the base iterator, /// then skipping forward `n - 1` elements. /// /// Iterator element type is `Self::Item`. /// /// **Panics** if the step is 0. /// /// ``` /// use itertools::Itertools; /// /// let it = (0..8).step(3); /// itertools::assert_equal(it, vec![0, 3, 6]); /// ``` #[deprecated(note="Use std .step_by() instead", since="0.8.0")] #[allow(deprecated)] fn step(self, n: usize) -> Step<Self> whereSelf: Sized
{
adaptors::step(self, n)
}
/// Convert each item of the iterator using the [`Into`] trait. /// /// ```rust /// use itertools::Itertools; /// /// (1i32..42i32).map_into::<f64>().collect_vec(); /// ``` fn map_into<R>(self) -> MapInto<Self, R> whereSelf: Sized, Self::Item: Into<R>,
{
adaptors::map_into(self)
}
/// Return an iterator adaptor that applies the provided closure /// to every `Result::Ok` value. `Result::Err` values are /// unchanged. /// /// ``` /// use itertools::Itertools; /// /// let input = vec![Ok(41), Err(false), Ok(11)]; /// let it = input.into_iter().map_ok(|i| i + 1); /// itertools::assert_equal(it, vec![Ok(42), Err(false), Ok(12)]); /// ``` fn map_ok<F, T, U, E>(self, f: F) -> MapOk<Self, F> whereSelf: Iterator<Item = Result<T, E>> + Sized,
F: FnMut(T) -> U,
{
adaptors::map_ok(self, f)
}
/// Return an iterator adaptor that filters every `Result::Ok` /// value with the provided closure. `Result::Err` values are /// unchanged. /// /// ``` /// use itertools::Itertools; /// /// let input = vec![Ok(22), Err(false), Ok(11)]; /// let it = input.into_iter().filter_ok(|&i| i > 20); /// itertools::assert_equal(it, vec![Ok(22), Err(false)]); /// ``` fn filter_ok<F, T, E>(self, f: F) -> FilterOk<Self, F> whereSelf: Iterator<Item = Result<T, E>> + Sized,
F: FnMut(&T) -> bool,
{
adaptors::filter_ok(self, f)
}
/// Return an iterator adaptor that filters and transforms every /// `Result::Ok` value with the provided closure. `Result::Err` /// values are unchanged. /// /// ``` /// use itertools::Itertools; /// /// let input = vec![Ok(22), Err(false), Ok(11)]; /// let it = input.into_iter().filter_map_ok(|i| if i > 20 { Some(i * 2) } else { None }); /// itertools::assert_equal(it, vec![Ok(44), Err(false)]); /// ``` fn filter_map_ok<F, T, U, E>(self, f: F) -> FilterMapOk<Self, F> whereSelf: Iterator<Item = Result<T, E>> + Sized,
F: FnMut(T) -> Option<U>,
{
adaptors::filter_map_ok(self, f)
}
/// Return an iterator adaptor that flattens every `Result::Ok` value into /// a series of `Result::Ok` values. `Result::Err` values are unchanged. /// /// This is useful when you have some common error type for your crate and /// need to propagate it upwards, but the `Result::Ok` case needs to be flattened. /// /// ``` /// use itertools::Itertools; /// /// let input = vec![Ok(0..2), Err(false), Ok(2..4)]; /// let it = input.iter().cloned().flatten_ok(); /// itertools::assert_equal(it.clone(), vec![Ok(0), Ok(1), Err(false), Ok(2), Ok(3)]); /// /// // This can also be used to propagate errors when collecting. /// let output_result: Result<Vec<i32>, bool> = it.collect(); /// assert_eq!(output_result, Err(false)); /// ``` fn flatten_ok<T, E>(self) -> FlattenOk<Self, T, E> whereSelf: Iterator<Item = Result<T, E>> + Sized,
T: IntoIterator
{
flatten_ok::flatten_ok(self)
}
/// Return an iterator adaptor that merges the two base iterators in /// ascending order. If both base iterators are sorted (ascending), the /// result is sorted. /// /// Iterator element type is `Self::Item`. /// /// ``` /// use itertools::Itertools; /// /// let a = (0..11).step(3); /// let b = (0..11).step(5); /// let it = a.merge(b); /// itertools::assert_equal(it, vec![0, 0, 3, 5, 6, 9, 10]); /// ``` fn merge<J>(self, other: J) -> Merge<Self, J::IntoIter> whereSelf: Sized, Self::Item: PartialOrd,
J: IntoIterator<Item = Self::Item>
{
merge(self, other)
}
/// Return an iterator adaptor that merges the two base iterators in order. /// This is much like [`.merge()`](Itertools::merge) but allows for a custom ordering. /// /// This can be especially useful for sequences of tuples. /// /// Iterator element type is `Self::Item`. /// /// ``` /// use itertools::Itertools; /// /// let a = (0..).zip("bc".chars()); /// let b = (0..).zip("ad".chars()); /// let it = a.merge_by(b, |x, y| x.1 <= y.1); /// itertools::assert_equal(it, vec![(0, 'a'), (0, 'b'), (1, 'c'), (1, 'd')]); /// ```
/// Create an iterator that merges items from both this and the specified /// iterator in ascending order. /// /// It chooses whether to pair elements based on the `Ordering` returned by the /// specified compare function. At any point, inspecting the tip of the /// iterators `I` and `J` as items `i` of type `I::Item` and `j` of type /// `J::Item` respectively, the resulting iterator will: /// /// - Emit `EitherOrBoth::Left(i)` when `i < j`, /// and remove `i` from its source iterator /// - Emit `EitherOrBoth::Right(j)` when `i > j`, /// and remove `j` from its source iterator /// - Emit `EitherOrBoth::Both(i, j)` when `i == j`, /// and remove both `i` and `j` from their respective source iterators /// /// ``` /// use itertools::Itertools; /// use itertools::EitherOrBoth::{Left, Right, Both}; /// /// let multiples_of_2 = (0..10).step(2); /// let multiples_of_3 = (0..10).step(3); /// /// itertools::assert_equal( /// multiples_of_2.merge_join_by(multiples_of_3, |i, j| i.cmp(j)), /// vec![Both(0, 0), Left(2), Right(3), Left(4), Both(6, 6), Left(8), Right(9)] /// ); /// ``` #[inline] fn merge_join_by<J, F>(self, other: J, cmp_fn: F) -> MergeJoinBy<Self, J::IntoIter, F> where J: IntoIterator,
F: FnMut(&Self::Item, &J::Item) -> std::cmp::Ordering, Self: Sized
{
merge_join_by(self, other, cmp_fn)
}
/// Return an iterator adaptor that flattens an iterator of iterators by /// merging them in ascending order. /// /// If all base iterators are sorted (ascending), the result is sorted. /// /// Iterator element type is `Self::Item`. /// /// ``` /// use itertools::Itertools; /// /// let a = (0..6).step(3); /// let b = (1..6).step(3); /// let c = (2..6).step(3); /// let it = vec![a, b, c].into_iter().kmerge(); /// itertools::assert_equal(it, vec![0, 1, 2, 3, 4, 5]); /// ``` #[cfg(feature = "use_alloc")] fn kmerge(self) -> KMerge<<Self::Item as IntoIterator>::IntoIter> whereSelf: Sized, Self::Item: IntoIterator,
<Self::Item as IntoIterator>::Item: PartialOrd,
{
kmerge(self)
}
/// Return an iterator adaptor that flattens an iterator of iterators by /// merging them according to the given closure. /// /// The closure `first` is called with two elements *a*, *b* and should /// return `true` if *a* is ordered before *b*. /// /// If all base iterators are sorted according to `first`, the result is /// sorted. /// /// Iterator element type is `Self::Item`. /// /// ``` /// use itertools::Itertools; /// /// let a = vec![-1f64, 2., 3., -5., 6., -7.]; /// let b = vec![0., 2., -4.]; /// let mut it = vec![a, b].into_iter().kmerge_by(|a, b| a.abs() < b.abs()); /// assert_eq!(it.next(), Some(0.)); /// assert_eq!(it.last(), Some(-7.)); /// ``` #[cfg(feature = "use_alloc")] fn kmerge_by<F>(self, first: F)
-> KMergeBy<<Self::Item as IntoIterator>::IntoIter, F> whereSelf: Sized, Self::Item: IntoIterator,
F: FnMut(&<Self::Item as IntoIterator>::Item,
&<Self::Item as IntoIterator>::Item) -> bool
{
kmerge_by(self, first)
}
/// Return an iterator adaptor that iterates over the cartesian product of /// the element sets of two iterators `self` and `J`. /// /// Iterator element type is `(Self::Item, J::Item)`. /// /// ``` /// use itertools::Itertools; /// /// let it = (0..2).cartesian_product("αβ".chars()); /// itertools::assert_equal(it, vec![(0, 'α'), (0, 'β'), (1, 'α'), (1, 'β')]); /// ``` fn cartesian_product<J>(self, other: J) -> Product<Self, J::IntoIter> whereSelf: Sized, Self::Item: Clone,
J: IntoIterator,
J::IntoIter: Clone
{
adaptors::cartesian_product(self, other.into_iter())
}
/// Return an iterator adaptor that iterates over the cartesian product of /// all subiterators returned by meta-iterator `self`. /// /// All provided iterators must yield the same `Item` type. To generate /// the product of iterators yielding multiple types, use the /// [`iproduct`] macro instead. /// /// /// The iterator element type is `Vec<T>`, where `T` is the iterator element /// of the subiterators. /// /// ``` /// use itertools::Itertools; /// let mut multi_prod = (0..3).map(|i| (i * 2)..(i * 2 + 2)) /// .multi_cartesian_product(); /// assert_eq!(multi_prod.next(), Some(vec![0, 2, 4])); /// assert_eq!(multi_prod.next(), Some(vec![0, 2, 5])); /// assert_eq!(multi_prod.next(), Some(vec![0, 3, 4])); /// assert_eq!(multi_prod.next(), Some(vec![0, 3, 5])); /// assert_eq!(multi_prod.next(), Some(vec![1, 2, 4])); /// assert_eq!(multi_prod.next(), Some(vec![1, 2, 5])); /// assert_eq!(multi_prod.next(), Some(vec![1, 3, 4])); /// assert_eq!(multi_prod.next(), Some(vec![1, 3, 5])); /// assert_eq!(multi_prod.next(), None); /// ``` #[cfg(feature = "use_alloc")] fn multi_cartesian_product(self) -> MultiProduct<<Self::Item as IntoIterator>::IntoIter> whereSelf: Sized, Self::Item: IntoIterator,
<Self::Item as IntoIterator>::IntoIter: Clone,
<Self::Item as IntoIterator>::Item: Clone
{
adaptors::multi_cartesian_product(self)
}
/// Return an iterator adaptor that uses the passed-in closure to /// optionally merge together consecutive elements. /// /// The closure `f` is passed two elements, `previous` and `current` and may /// return either (1) `Ok(combined)` to merge the two values or /// (2) `Err((previous', current'))` to indicate they can't be merged. /// In (2), the value `previous'` is emitted by the iterator. /// Either (1) `combined` or (2) `current'` becomes the previous value /// when coalesce continues with the next pair of elements to merge. The /// value that remains at the end is also emitted by the iterator. /// /// Iterator element type is `Self::Item`. /// /// This iterator is *fused*. /// /// ``` /// use itertools::Itertools; /// /// // sum same-sign runs together /// let data = vec![-1., -2., -3., 3., 1., 0., -1.]; /// itertools::assert_equal(data.into_iter().coalesce(|x, y| /// if (x >= 0.) == (y >= 0.) { /// Ok(x + y) /// } else { /// Err((x, y)) /// }), /// vec![-6., 4., -1.]); /// ``` fn coalesce<F>(self, f: F) -> Coalesce<Self, F> whereSelf: Sized,
F: FnMut(Self::Item, Self::Item)
-> Result<Self::Item, (Self::Item, Self::Item)>
{
adaptors::coalesce(self, f)
}
/// Remove duplicates from sections of consecutive identical elements. /// If the iterator is sorted, all elements will be unique. /// /// Iterator element type is `Self::Item`. /// /// This iterator is *fused*. /// /// ``` /// use itertools::Itertools; /// /// let data = vec![1., 1., 2., 3., 3., 2., 2.]; /// itertools::assert_equal(data.into_iter().dedup(), /// vec![1., 2., 3., 2.]); /// ``` fn dedup(self) -> Dedup<Self> whereSelf: Sized, Self::Item: PartialEq,
{
adaptors::dedup(self)
}
/// Remove duplicates from sections of consecutive identical elements, /// determining equality using a comparison function. /// If the iterator is sorted, all elements will be unique. /// /// Iterator element type is `Self::Item`. /// /// This iterator is *fused*. /// /// ``` /// use itertools::Itertools; /// /// let data = vec![(0, 1.), (1, 1.), (0, 2.), (0, 3.), (1, 3.), (1, 2.), (2, 2.)]; /// itertools::assert_equal(data.into_iter().dedup_by(|x, y| x.1 == y.1), /// vec![(0, 1.), (0, 2.), (0, 3.), (1, 2.)]); /// ``` fn dedup_by<Cmp>(self, cmp: Cmp) -> DedupBy<Self, Cmp> whereSelf: Sized,
Cmp: FnMut(&Self::Item, &Self::Item)->bool,
{
adaptors::dedup_by(self, cmp)
}
/// Remove duplicates from sections of consecutive identical elements, while keeping a count of /// how many repeated elements were present. /// If the iterator is sorted, all elements will be unique. /// /// Iterator element type is `(usize, Self::Item)`. /// /// This iterator is *fused*. /// /// ``` /// use itertools::Itertools; /// /// let data = vec!['a', 'a', 'b', 'c', 'c', 'b', 'b']; /// itertools::assert_equal(data.into_iter().dedup_with_count(), /// vec![(2, 'a'), (1, 'b'), (2, 'c'), (2, 'b')]); /// ``` fn dedup_with_count(self) -> DedupWithCount<Self> where Self: Sized,
{
adaptors::dedup_with_count(self)
}
/// Remove duplicates from sections of consecutive identical elements, while keeping a count of /// how many repeated elements were present. /// This will determine equality using a comparison function. /// If the iterator is sorted, all elements will be unique. /// /// Iterator element type is `(usize, Self::Item)`. /// /// This iterator is *fused*. /// /// ``` /// use itertools::Itertools; /// /// let data = vec![(0, 'a'), (1, 'a'), (0, 'b'), (0, 'c'), (1, 'c'), (1, 'b'), (2, 'b')]; /// itertools::assert_equal(data.into_iter().dedup_by_with_count(|x, y| x.1 == y.1), /// vec![(2, (0, 'a')), (1, (0, 'b')), (2, (0, 'c')), (2, (1, 'b'))]); /// ``` fn dedup_by_with_count<Cmp>(self, cmp: Cmp) -> DedupByWithCount<Self, Cmp> where Self: Sized,
Cmp: FnMut(&Self::Item, &Self::Item) -> bool,
{
adaptors::dedup_by_with_count(self, cmp)
}
/// Return an iterator adaptor that produces elements that appear more than once during the /// iteration. Duplicates are detected using hash and equality. /// /// The iterator is stable, returning the duplicate items in the order in which they occur in /// the adapted iterator. Each duplicate item is returned exactly once. If an item appears more /// than twice, the second item is the item retained and the rest are discarded. /// /// ``` /// use itertools::Itertools; /// /// let data = vec![10, 20, 30, 20, 40, 10, 50]; /// itertools::assert_equal(data.into_iter().duplicates(), /// vec![20, 10]); /// ``` #[cfg(feature = "use_std")] fn duplicates(self) -> Duplicates<Self> whereSelf: Sized, Self::Item: Eq + Hash
{
duplicates_impl::duplicates(self)
}
/// Return an iterator adaptor that produces elements that appear more than once during the /// iteration. Duplicates are detected using hash and equality. /// /// Duplicates are detected by comparing the key they map to with the keying function `f` by /// hash and equality. The keys are stored in a hash map in the iterator. /// /// The iterator is stable, returning the duplicate items in the order in which they occur in /// the adapted iterator. Each duplicate item is returned exactly once. If an item appears more /// than twice, the second item is the item retained and the rest are discarded. /// /// ``` /// use itertools::Itertools; /// /// let data = vec!["a", "bb", "aa", "c", "ccc"]; /// itertools::assert_equal(data.into_iter().duplicates_by(|s| s.len()), /// vec!["aa", "c"]); /// ``` #[cfg(feature = "use_std")] fn duplicates_by<V, F>(self, f: F) -> DuplicatesBy<Self, V, F> whereSelf: Sized,
V: Eq + Hash,
F: FnMut(&Self::Item) -> V
{
duplicates_impl::duplicates_by(self, f)
}
/// Return an iterator adaptor that filters out elements that have /// already been produced once during the iteration. Duplicates /// are detected using hash and equality. /// /// Clones of visited elements are stored in a hash set in the /// iterator. /// /// The iterator is stable, returning the non-duplicate items in the order /// in which they occur in the adapted iterator. In a set of duplicate /// items, the first item encountered is the item retained. /// /// ``` /// use itertools::Itertools; /// /// let data = vec![10, 20, 30, 20, 40, 10, 50]; /// itertools::assert_equal(data.into_iter().unique(), /// vec![10, 20, 30, 40, 50]); /// ``` #[cfg(feature = "use_std")] fn unique(self) -> Unique<Self> whereSelf: Sized, Self::Item: Clone + Eq + Hash
{
unique_impl::unique(self)
}
/// Return an iterator adaptor that filters out elements that have /// already been produced once during the iteration. /// /// Duplicates are detected by comparing the key they map to /// with the keying function `f` by hash and equality. /// The keys are stored in a hash set in the iterator. /// /// The iterator is stable, returning the non-duplicate items in the order /// in which they occur in the adapted iterator. In a set of duplicate /// items, the first item encountered is the item retained. /// /// ``` /// use itertools::Itertools; /// /// let data = vec!["a", "bb", "aa", "c", "ccc"]; /// itertools::assert_equal(data.into_iter().unique_by(|s| s.len()), /// vec!["a", "bb", "ccc"]); /// ``` #[cfg(feature = "use_std")] fn unique_by<V, F>(self, f: F) -> UniqueBy<Self, V, F> whereSelf: Sized,
V: Eq + Hash,
F: FnMut(&Self::Item) -> V
{
unique_impl::unique_by(self, f)
}
/// Return an iterator adaptor that borrows from this iterator and /// takes items while the closure `accept` returns `true`. /// /// This adaptor can only be used on iterators that implement `PeekingNext` /// like `.peekable()`, `put_back` and a few other collection iterators. /// /// The last and rejected element (first `false`) is still available when /// `peeking_take_while` is done. /// /// /// See also [`.take_while_ref()`](Itertools::take_while_ref) /// which is a similar adaptor. fn peeking_take_while<F>(&mutself, accept: F) -> PeekingTakeWhile<Self, F> whereSelf: Sized + PeekingNext,
F: FnMut(&Self::Item) -> bool,
{
peeking_take_while::peeking_take_while(self, accept)
}
/// Return an iterator adaptor that borrows from a `Clone`-able iterator /// to only pick off elements while the predicate `accept` returns `true`. /// /// It uses the `Clone` trait to restore the original iterator so that the /// last and rejected element (first `false`) is still available when /// `take_while_ref` is done. /// /// ``` /// use itertools::Itertools; /// /// let mut hexadecimals = "0123456789abcdef".chars(); /// /// let decimals = hexadecimals.take_while_ref(|c| c.is_numeric()) /// .collect::<String>(); /// assert_eq!(decimals, "0123456789"); /// assert_eq!(hexadecimals.next(), Some('a')); /// /// ``` fn take_while_ref<F>(&mutself, accept: F) -> TakeWhileRef<Self, F> whereSelf: Clone,
F: FnMut(&Self::Item) -> bool
{
adaptors::take_while_ref(self, accept)
}
/// Return an iterator adaptor that filters `Option<A>` iterator elements /// and produces `A`. Stops on the first `None` encountered. /// /// Iterator element type is `A`, the unwrapped element. /// /// ``` /// use itertools::Itertools; /// /// // List all hexadecimal digits /// itertools::assert_equal( /// (0..).map(|i| std::char::from_digit(i, 16)).while_some(), /// "0123456789abcdef".chars()); /// /// ``` fn while_some<A>(self) -> WhileSome<Self> whereSelf: Sized + Iterator<Item = Option<A>>
{
adaptors::while_some(self)
}
/// Return an iterator adaptor that iterates over the combinations of the /// elements from an iterator. /// /// Iterator element can be any homogeneous tuple of type `Self::Item` with /// size up to 12. /// /// ``` /// use itertools::Itertools; /// /// let mut v = Vec::new(); /// for (a, b) in (1..5).tuple_combinations() { /// v.push((a, b)); /// } /// assert_eq!(v, vec![(1, 2), (1, 3), (1, 4), (2, 3), (2, 4), (3, 4)]); /// /// let mut it = (1..5).tuple_combinations(); /// assert_eq!(Some((1, 2, 3)), it.next()); /// assert_eq!(Some((1, 2, 4)), it.next()); /// assert_eq!(Some((1, 3, 4)), it.next()); /// assert_eq!(Some((2, 3, 4)), it.next()); /// assert_eq!(None, it.next()); /// /// // this requires a type hint /// let it = (1..5).tuple_combinations::<(_, _, _)>(); /// itertools::assert_equal(it, vec![(1, 2, 3), (1, 2, 4), (1, 3, 4), (2, 3, 4)]); /// /// // you can also specify the complete type /// use itertools::TupleCombinations; /// use std::ops::Range; /// /// let it: TupleCombinations<Range<u32>, (u32, u32, u32)> = (1..5).tuple_combinations(); /// itertools::assert_equal(it, vec![(1, 2, 3), (1, 2, 4), (1, 3, 4), (2, 3, 4)]); /// ``` fn tuple_combinations<T>(self) -> TupleCombinations<Self, T> whereSelf: Sized + Clone, Self::Item: Clone,
T: adaptors::HasCombination<Self>,
{
adaptors::tuple_combinations(self)
}
/// Return an iterator adaptor that iterates over the `k`-length combinations of /// the elements from an iterator. /// /// Iterator element type is `Vec<Self::Item>`. The iterator produces a new Vec per iteration, /// and clones the iterator elements. /// /// ``` /// use itertools::Itertools; /// /// let it = (1..5).combinations(3); /// itertools::assert_equal(it, vec![ /// vec![1, 2, 3], /// vec![1, 2, 4], /// vec![1, 3, 4], /// vec![2, 3, 4], /// ]); /// ``` /// /// Note: Combinations does not take into account the equality of the iterated values. /// ``` /// use itertools::Itertools; /// /// let it = vec![1, 2, 2].into_iter().combinations(2); /// itertools::assert_equal(it, vec![ /// vec![1, 2], // Note: these are the same /// vec![1, 2], // Note: these are the same /// vec![2, 2], /// ]); /// ``` #[cfg(feature = "use_alloc")] fn combinations(self, k: usize) -> Combinations<Self> whereSelf: Sized, Self::Item: Clone
{
combinations::combinations(self, k)
}
/// Return an iterator that iterates over the `k`-length combinations of /// the elements from an iterator, with replacement. /// /// Iterator element type is `Vec<Self::Item>`. The iterator produces a new Vec per iteration, /// and clones the iterator elements. /// /// ``` /// use itertools::Itertools; /// /// let it = (1..4).combinations_with_replacement(2); /// itertools::assert_equal(it, vec![ /// vec![1, 1], /// vec![1, 2], /// vec![1, 3], /// vec![2, 2], /// vec![2, 3], /// vec![3, 3], /// ]); /// ``` #[cfg(feature = "use_alloc")] fn combinations_with_replacement(self, k: usize) -> CombinationsWithReplacement<Self> where Self: Sized, Self::Item: Clone,
{
combinations_with_replacement::combinations_with_replacement(self, k)
}
/// Return an iterator adaptor that iterates over all k-permutations of the /// elements from an iterator. /// /// Iterator element type is `Vec<Self::Item>` with length `k`. The iterator /// produces a new Vec per iteration, and clones the iterator elements. /// /// If `k` is greater than the length of the input iterator, the resultant /// iterator adaptor will be empty. /// /// ``` /// use itertools::Itertools; /// /// let perms = (5..8).permutations(2); /// itertools::assert_equal(perms, vec![ /// vec![5, 6], /// vec![5, 7], /// vec![6, 5], /// vec![6, 7], /// vec![7, 5], /// vec![7, 6], /// ]); /// ``` /// /// Note: Permutations does not take into account the equality of the iterated values. /// /// ``` /// use itertools::Itertools; /// /// let it = vec![2, 2].into_iter().permutations(2); /// itertools::assert_equal(it, vec![ /// vec![2, 2], // Note: these are the same /// vec![2, 2], // Note: these are the same /// ]); /// ``` /// /// Note: The source iterator is collected lazily, and will not be /// re-iterated if the permutations adaptor is completed and re-iterated. #[cfg(feature = "use_alloc")] fn permutations(self, k: usize) -> Permutations<Self> whereSelf: Sized, Self::Item: Clone
{
permutations::permutations(self, k)
}
/// Return an iterator that iterates through the powerset of the elements from an /// iterator. /// /// Iterator element type is `Vec<Self::Item>`. The iterator produces a new `Vec` /// per iteration, and clones the iterator elements. /// /// The powerset of a set contains all subsets including the empty set and the full /// input set. A powerset has length _2^n_ where _n_ is the length of the input /// set. /// /// Each `Vec` produced by this iterator represents a subset of the elements /// produced by the source iterator. /// /// ``` /// use itertools::Itertools; /// /// let sets = (1..4).powerset().collect::<Vec<_>>(); /// itertools::assert_equal(sets, vec![ /// vec![], /// vec![1], /// vec![2], /// vec![3], /// vec![1, 2], /// vec![1, 3], /// vec![2, 3], /// vec![1, 2, 3], /// ]); /// ``` #[cfg(feature = "use_alloc")] fn powerset(self) -> Powerset<Self> whereSelf: Sized, Self::Item: Clone,
{
powerset::powerset(self)
}
/// Return an iterator adaptor that pads the sequence to a minimum length of /// `min` by filling missing elements using a closure `f`. /// /// Iterator element type is `Self::Item`. /// /// ``` /// use itertools::Itertools; /// /// let it = (0..5).pad_using(10, |i| 2*i); /// itertools::assert_equal(it, vec![0, 1, 2, 3, 4, 10, 12, 14, 16, 18]); /// /// let it = (0..10).pad_using(5, |i| 2*i); /// itertools::assert_equal(it, vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9]); /// /// let it = (0..5).pad_using(10, |i| 2*i).rev(); /// itertools::assert_equal(it, vec![18, 16, 14, 12, 10, 4, 3, 2, 1, 0]); /// ``` fn pad_using<F>(self, min: usize, f: F) -> PadUsing<Self, F> whereSelf: Sized,
F: FnMut(usize) -> Self::Item
{
pad_tail::pad_using(self, min, f)
}
/// Return an iterator adaptor that wraps each element in a `Position` to /// ease special-case handling of the first or last elements. /// /// Iterator element type is /// [`Position<Self::Item>`](Position) /// /// ``` /// use itertools::{Itertools, Position}; /// /// let it = (0..4).with_position(); /// itertools::assert_equal(it, /// vec![Position::First(0), /// Position::Middle(1), /// Position::Middle(2), /// Position::Last(3)]); /// /// let it = (0..1).with_position(); /// itertools::assert_equal(it, vec![Position::Only(0)]); /// ``` fn with_position(self) -> WithPosition<Self> whereSelf: Sized,
{
with_position::with_position(self)
}
/// Return an iterator adaptor that yields the indices of all elements /// satisfying a predicate, counted from the start of the iterator. /// /// Equivalent to `iter.enumerate().filter(|(_, v)| predicate(v)).map(|(i, _)| i)`. /// /// ``` /// use itertools::Itertools; /// /// let data = vec![1, 2, 3, 3, 4, 6, 7, 9]; /// itertools::assert_equal(data.iter().positions(|v| v % 2 == 0), vec![1, 4, 5]); /// /// itertools::assert_equal(data.iter().positions(|v| v % 2 == 1).rev(), vec![7, 6, 3, 2, 0]); /// ``` fn positions<P>(self, predicate: P) -> Positions<Self, P> whereSelf: Sized,
P: FnMut(Self::Item) -> bool,
{
adaptors::positions(self, predicate)
}
/// Return an iterator adaptor that applies a mutating function /// to each element before yielding it. /// /// ``` /// use itertools::Itertools; /// /// let input = vec![vec![1], vec![3, 2, 1]]; /// let it = input.into_iter().update(|mut v| v.push(0)); /// itertools::assert_equal(it, vec![vec![1, 0], vec![3, 2, 1, 0]]); /// ``` fn update<F>(self, updater: F) -> Update<Self, F> whereSelf: Sized,
F: FnMut(&mutSelf::Item),
{
adaptors::update(self, updater)
}
// non-adaptor methods /// Advances the iterator and returns the next items grouped in a tuple of /// a specific size (up to 12). /// /// If there are enough elements to be grouped in a tuple, then the tuple is /// returned inside `Some`, otherwise `None` is returned. /// /// ``` /// use itertools::Itertools; /// /// let mut iter = 1..5; /// /// assert_eq!(Some((1, 2)), iter.next_tuple()); /// ``` fn next_tuple<T>(&mutself) -> Option<T> whereSelf: Sized + Iterator<Item = T::Item>,
T: traits::HomogeneousTuple
{
T::collect_from_iter_no_buf(self)
}
/// Collects all items from the iterator into a tuple of a specific size /// (up to 12). /// /// If the number of elements inside the iterator is **exactly** equal to /// the tuple size, then the tuple is returned inside `Some`, otherwise /// `None` is returned. /// /// ``` /// use itertools::Itertools; /// /// let iter = 1..3; /// /// if let Some((x, y)) = iter.collect_tuple() { /// assert_eq!((x, y), (1, 2)) /// } else { /// panic!("Expected two elements") /// } /// ``` fn collect_tuple<T>(mutself) -> Option<T> whereSelf: Sized + Iterator<Item = T::Item>,
T: traits::HomogeneousTuple
{ matchself.next_tuple() {
elt @ Some(_) => matchself.next() {
Some(_) => None,
None => elt,
},
_ => None
}
}
/// Find the position and value of the first element satisfying a predicate. /// /// The iterator is not advanced past the first element found. /// /// ``` /// use itertools::Itertools; /// /// let text = "Hα"; /// assert_eq!(text.chars().find_position(|ch| ch.is_lowercase()), Some((1, 'α'))); /// ``` fn find_position<P>(&mutself, mut pred: P) -> Option<(usize, Self::Item)> where P: FnMut(&Self::Item) -> bool
{ for (index, elt) inself.enumerate() { if pred(&elt) { return Some((index, elt));
}
}
None
} /// Find the value of the first element satisfying a predicate or return the last element, if any. /// /// The iterator is not advanced past the first element found. /// /// ``` /// use itertools::Itertools; /// /// let numbers = [1, 2, 3, 4]; /// assert_eq!(numbers.iter().find_or_last(|&&x| x > 5), Some(&4)); /// assert_eq!(numbers.iter().find_or_last(|&&x| x > 2), Some(&3)); /// assert_eq!(std::iter::empty::<i32>().find_or_last(|&x| x > 5), None); /// ``` fn find_or_last<P>(mutself, mut predicate: P) -> Option<Self::Item> whereSelf: Sized,
P: FnMut(&Self::Item) -> bool,
{ letmut prev = None; self.find_map(|x| if predicate(&x) { Some(x) } else { prev = Some(x); None })
.or(prev)
} /// Find the value of the first element satisfying a predicate or return the first element, if any. /// /// The iterator is not advanced past the first element found. /// /// ``` /// use itertools::Itertools; /// /// let numbers = [1, 2, 3, 4]; /// assert_eq!(numbers.iter().find_or_first(|&&x| x > 5), Some(&1)); /// assert_eq!(numbers.iter().find_or_first(|&&x| x > 2), Some(&3)); /// assert_eq!(std::iter::empty::<i32>().find_or_first(|&x| x > 5), None); /// ``` fn find_or_first<P>(mutself, mut predicate: P) -> Option<Self::Item> whereSelf: Sized,
P: FnMut(&Self::Item) -> bool,
{ let first = self.next()?;
Some(if predicate(&first) {
first
} else { self.find(|x| predicate(x)).unwrap_or(first)
})
} /// Returns `true` if the given item is present in this iterator. /// /// This method is short-circuiting. If the given item is present in this /// iterator, this method will consume the iterator up-to-and-including /// the item. If the given item is not present in this iterator, the /// iterator will be exhausted. /// /// ``` /// use itertools::Itertools; /// /// #[derive(PartialEq, Debug)] /// enum Enum { A, B, C, D, E, } /// /// let mut iter = vec![Enum::A, Enum::B, Enum::C, Enum::D].into_iter(); /// /// // search `iter` for `B` /// assert_eq!(iter.contains(&Enum::B), true); /// // `B` was found, so the iterator now rests at the item after `B` (i.e, `C`). /// assert_eq!(iter.next(), Some(Enum::C)); /// /// // search `iter` for `E` /// assert_eq!(iter.contains(&Enum::E), false); /// // `E` wasn't found, so `iter` is now exhausted /// assert_eq!(iter.next(), None); /// ``` fn contains<Q>(&mutself, query: &Q) -> bool where Self: Sized, Self::Item: Borrow<Q>,
Q: PartialEq,
{ self.any(|x| x.borrow() == query)
}
/// Check whether all elements compare equal. /// /// Empty iterators are considered to have equal elements: /// /// ``` /// use itertools::Itertools; /// /// let data = vec![1, 1, 1, 2, 2, 3, 3, 3, 4, 5, 5]; /// assert!(!data.iter().all_equal()); /// assert!(data[0..3].iter().all_equal()); /// assert!(data[3..5].iter().all_equal()); /// assert!(data[5..8].iter().all_equal()); /// /// let data : Option<usize> = None; /// assert!(data.into_iter().all_equal()); /// ``` fn all_equal(&mutself) -> bool whereSelf: Sized, Self::Item: PartialEq,
{ matchself.next() {
None => true,
Some(a) => self.all(|x| a == x),
}
}
/// Check whether all elements are unique (non equal). /// /// Empty iterators are considered to have unique elements: /// /// ``` /// use itertools::Itertools; /// /// let data = vec![1, 2, 3, 4, 1, 5]; /// assert!(!data.iter().all_unique()); /// assert!(data[0..4].iter().all_unique()); /// assert!(data[1..6].iter().all_unique()); /// /// let data : Option<usize> = None; /// assert!(data.into_iter().all_unique()); /// ``` #[cfg(feature = "use_std")] fn all_unique(&mutself) -> bool whereSelf: Sized, Self::Item: Eq + Hash
{ letmut used = HashSet::new(); self.all(move |elt| used.insert(elt))
}
/// Consume the first `n` elements from the iterator eagerly, /// and return the same iterator again. /// /// It works similarly to *.skip(* `n` *)* except it is eager and /// preserves the iterator type. /// /// ``` /// use itertools::Itertools; /// /// let mut iter = "αβγ".chars().dropping(2); /// itertools::assert_equal(iter, "γ".chars()); /// ``` /// /// *Fusing notes: if the iterator is exhausted by dropping, /// the result of calling `.next()` again depends on the iterator implementation.* fn dropping(mutself, n: usize) -> Self whereSelf: Sized
{ if n > 0 { self.nth(n - 1);
} self
}
/// Consume the last `n` elements from the iterator eagerly, /// and return the same iterator again. /// /// This is only possible on double ended iterators. `n` may be /// larger than the number of elements. /// /// Note: This method is eager, dropping the back elements immediately and /// preserves the iterator type. /// /// ``` /// use itertools::Itertools; /// /// let init = vec![0, 3, 6, 9].into_iter().dropping_back(1); /// itertools::assert_equal(init, vec![0, 3, 6]); /// ``` fn dropping_back(mutself, n: usize) -> Self whereSelf: Sized, Self: DoubleEndedIterator
{ if n > 0 {
(&mutself).rev().nth(n - 1);
} self
}
/// Run the closure `f` eagerly on each element of the iterator. /// /// Consumes the iterator until its end. /// /// ``` /// use std::sync::mpsc::channel; /// use itertools::Itertools; /// /// let (tx, rx) = channel(); /// /// // use .foreach() to apply a function to each value -- sending it /// (0..5).map(|x| x * 2 + 1).foreach(|x| { tx.send(x).unwrap(); } ); /// /// drop(tx); /// /// itertools::assert_equal(rx.iter(), vec![1, 3, 5, 7, 9]); /// ``` #[deprecated(note="Use .for_each() instead", since="0.8.0")] fn foreach<F>(self, f: F) where F: FnMut(Self::Item), Self: Sized,
{ self.for_each(f);
}
/// Combine all an iterator's elements into one element by using [`Extend`]. /// /// This combinator will extend the first item with each of the rest of the /// items of the iterator. If the iterator is empty, the default value of /// `I::Item` is returned. /// /// ```rust /// use itertools::Itertools; /// /// let input = vec![vec![1], vec![2, 3], vec![4, 5, 6]]; /// assert_eq!(input.into_iter().concat(), /// vec![1, 2, 3, 4, 5, 6]); /// ``` fn concat(self) -> Self::Item whereSelf: Sized, Self::Item: Extend<<<Selfas Iterator>::Item as IntoIterator>::Item> + IntoIterator + Default
{
concat(self)
}
/// `.collect_vec()` is simply a type specialization of [`Iterator::collect`], /// for convenience. #[cfg(feature = "use_alloc")] fn collect_vec(self) -> Vec<Self::Item> whereSelf: Sized
{ self.collect()
}
/// `.try_collect()` is more convenient way of writing /// `.collect::<Result<_, _>>()` /// /// # Example /// /// ``` /// use std::{fs, io}; /// use itertools::Itertools; /// /// fn process_dir_entries(entries: &[fs::DirEntry]) { /// // ... /// } /// /// fn do_stuff() -> std::io::Result<()> { /// let entries: Vec<_> = fs::read_dir(".")?.try_collect()?; /// process_dir_entries(&entries); /// /// Ok(()) /// } /// ``` #[cfg(feature = "use_alloc")] fn try_collect<T, U, E>(self) -> Result<U, E> where Self: Sized + Iterator<Item = Result<T, E>>,
Result<U, E>: FromIterator<Result<T, E>>,
{ self.collect()
}
/// Assign to each reference in `self` from the `from` iterator, /// stopping at the shortest of the two iterators. /// /// The `from` iterator is queried for its next element before the `self` /// iterator, and if either is exhausted the method is done. /// /// Return the number of elements written. /// /// ``` /// use itertools::Itertools; /// /// let mut xs = [0; 4]; /// xs.iter_mut().set_from(1..); /// assert_eq!(xs, [1, 2, 3, 4]); /// ``` #[inline] fn set_from<'a, A: 'a, J>(&mutself, from: J) -> usize whereSelf: Iterator<Item = &'a mut A>,
J: IntoIterator<Item = A>
{ letmut count = 0; for elt in from { matchself.next() {
None => break,
Some(ptr) => *ptr = elt,
}
count += 1;
}
count
}
/// Combine all iterator elements into one String, separated by `sep`. /// /// Use the `Display` implementation of each element. /// /// ``` /// use itertools::Itertools; /// /// assert_eq!(["a", "b", "c"].iter().join(", "), "a, b, c"); /// assert_eq!([1, 2, 3].iter().join(", "), "1, 2, 3"); /// ``` #[cfg(feature = "use_alloc")] fn join(&mutself, sep: &str) -> String whereSelf::Item: std::fmt::Display
{ matchself.next() {
None => String::new(),
Some(first_elt) => { // estimate lower bound of capacity needed let (lower, _) = self.size_hint(); letmut result = String::with_capacity(sep.len() * lower);
write!(&mut result, "{}", first_elt).unwrap(); self.for_each(|elt| {
result.push_str(sep);
write!(&mut result, "{}", elt).unwrap();
});
result
}
}
}
/// Format all iterator elements, separated by `sep`. /// /// All elements are formatted (any formatting trait) /// with `sep` inserted between each element. /// /// **Panics** if the formatter helper is formatted more than once. /// /// ``` /// use itertools::Itertools; /// /// let data = [1.1, 2.71828, -3.]; /// assert_eq!( /// format!("{:.2}", data.iter().format(", ")), /// "1.10, 2.72, -3.00"); /// ``` fn format(self, sep: &str) -> Format<Self> whereSelf: Sized,
{
format::new_format_default(self, sep)
}
/// Format all iterator elements, separated by `sep`. /// /// This is a customizable version of [`.format()`](Itertools::format). /// /// The supplied closure `format` is called once per iterator element, /// with two arguments: the element and a callback that takes a /// `&Display` value, i.e. any reference to type that implements `Display`. /// /// Using `&format_args!(...)` is the most versatile way to apply custom /// element formatting. The callback can be called multiple times if needed. /// /// **Panics** if the formatter helper is formatted more than once. /// /// ``` /// use itertools::Itertools; /// /// let data = [1.1, 2.71828, -3.]; /// let data_formatter = data.iter().format_with(", ", |elt, f| f(&format_args!("{:.2}", elt))); /// assert_eq!(format!("{}", data_formatter), /// "1.10, 2.72, -3.00"); /// /// // .format_with() is recursively composable /// let matrix = [[1., 2., 3.], /// [4., 5., 6.]]; /// let matrix_formatter = matrix.iter().format_with("\n", |row, f| { /// f(&row.iter().format_with(", ", |elt, g| g(&elt))) /// }); /// assert_eq!(format!("{}", matrix_formatter), /// "1, 2, 3\n4, 5, 6"); /// /// /// ``` fn format_with<F>(self, sep: &str, format: F) -> FormatWith<Self, F> whereSelf: Sized,
F: FnMut(Self::Item, &mutdyn FnMut(&dynfmt::Display) -> fmt::Result) -> fmt::Result,
{
format::new_format(self, sep, format)
}
/// See [`.fold_ok()`](Itertools::fold_ok). #[deprecated(note="Use .fold_ok() instead", since="0.10.0")] fn fold_results<A, E, B, F>(&mutself, start: B, f: F) -> Result<B, E> whereSelf: Iterator<Item = Result<A, E>>,
F: FnMut(B, A) -> B
{ self.fold_ok(start, f)
}
/// Fold `Result` values from an iterator. /// /// Only `Ok` values are folded. If no error is encountered, the folded /// value is returned inside `Ok`. Otherwise, the operation terminates /// and returns the first `Err` value it encounters. No iterator elements are /// consumed after the first error. /// /// The first accumulator value is the `start` parameter. /// Each iteration passes the accumulator value and the next value inside `Ok` /// to the fold function `f` and its return value becomes the new accumulator value. /// /// For example the sequence *Ok(1), Ok(2), Ok(3)* will result in a /// computation like this: /// /// ```ignore /// let mut accum = start; /// accum = f(accum, 1); /// accum = f(accum, 2); /// accum = f(accum, 3); /// ``` /// /// With a `start` value of 0 and an addition as folding function, /// this effectively results in *((0 + 1) + 2) + 3* /// /// ``` /// use std::ops::Add; /// use itertools::Itertools; /// /// let values = [1, 2, -2, -1, 2, 1]; /// assert_eq!( /// values.iter() /// .map(Ok::<_, ()>) /// .fold_ok(0, Add::add), /// Ok(3) /// ); /// assert!( /// values.iter() /// .map(|&x| if x >= 0 { Ok(x) } else { Err("Negative number") }) /// .fold_ok(0, Add::add) /// .is_err() /// ); /// ``` fn fold_ok<A, E, B, F>(&mutself, mut start: B, mut f: F) -> Result<B, E> whereSelf: Iterator<Item = Result<A, E>>,
F: FnMut(B, A) -> B
{ for elt inself { match elt {
Ok(v) => start = f(start, v),
Err(u) => return Err(u),
}
}
Ok(start)
}
/// Fold `Option` values from an iterator. /// /// Only `Some` values are folded. If no `None` is encountered, the folded /// value is returned inside `Some`. Otherwise, the operation terminates /// and returns `None`. No iterator elements are consumed after the `None`. /// /// This is the `Option` equivalent to [`fold_ok`](Itertools::fold_ok). /// /// ``` /// use std::ops::Add; /// use itertools::Itertools; /// /// let mut values = vec![Some(1), Some(2), Some(-2)].into_iter(); /// assert_eq!(values.fold_options(5, Add::add), Some(5 + 1 + 2 - 2)); /// /// let mut more_values = vec![Some(2), None, Some(0)].into_iter(); /// assert!(more_values.fold_options(0, Add::add).is_none()); /// assert_eq!(more_values.next().unwrap(), Some(0)); /// ``` fn fold_options<A, B, F>(&mutself, mut start: B, mut f: F) -> Option<B> whereSelf: Iterator<Item = Option<A>>,
F: FnMut(B, A) -> B
{ for elt inself { match elt {
Some(v) => start = f(start, v),
None => return None,
}
}
Some(start)
}
/// Accumulator of the elements in the iterator. /// /// Like `.fold()`, without a base case. If the iterator is /// empty, return `None`. With just one element, return it. /// Otherwise elements are accumulated in sequence using the closure `f`. /// /// ``` /// use itertools::Itertools; /// /// assert_eq!((0..10).fold1(|x, y| x + y).unwrap_or(0), 45); /// assert_eq!((0..0).fold1(|x, y| x * y), None); /// ``` #[deprecated(since = "0.10.2", note = "Use `Iterator::reduce` instead")] fn fold1<F>(mutself, f: F) -> Option<Self::Item> where F: FnMut(Self::Item, Self::Item) -> Self::Item, Self: Sized,
{ self.next().map(move |x| self.fold(x, f))
}
/// Accumulate the elements in the iterator in a tree-like manner. /// /// You can think of it as, while there's more than one item, repeatedly /// combining adjacent items. It does so in bottom-up-merge-sort order, /// however, so that it needs only logarithmic stack space. /// /// This produces a call tree like the following (where the calls under /// an item are done after reading that item): /// /// ```text /// 1 2 3 4 5 6 7 /// │ │ │ │ │ │ │ /// └─f └─f └─f │ /// │ │ │ │ /// └───f └─f /// │ │ /// └─────f /// ``` /// /// Which, for non-associative functions, will typically produce a different /// result than the linear call tree used by [`Iterator::reduce`]: /// /// ```text /// 1 2 3 4 5 6 7 /// │ │ │ │ │ │ │ /// └─f─f─f─f─f─f /// ``` /// /// If `f` is associative, prefer the normal [`Iterator::reduce`] instead. /// /// ``` /// use itertools::Itertools; /// /// // The same tree as above /// let num_strings = (1..8).map(|x| x.to_string()); /// assert_eq!(num_strings.tree_fold1(|x, y| format!("f({}, {})", x, y)), /// Some(String::from("f(f(f(1, 2), f(3, 4)), f(f(5, 6), 7))"))); /// /// // Like fold1, an empty iterator produces None /// assert_eq!((0..0).tree_fold1(|x, y| x * y), None); /// /// // tree_fold1 matches fold1 for associative operations... /// assert_eq!((0..10).tree_fold1(|x, y| x + y), /// (0..10).fold1(|x, y| x + y)); /// // ...but not for non-associative ones /// assert_ne!((0..10).tree_fold1(|x, y| x - y), /// (0..10).fold1(|x, y| x - y)); /// ``` fn tree_fold1<F>(mutself, mut f: F) -> Option<Self::Item> where F: FnMut(Self::Item, Self::Item) -> Self::Item, Self: Sized,
{ type State<T> = Result<T, Option<T>>;
fn inner0<T, II, FF>(it: &mut II, f: &mut FF) -> State<T> where
II: Iterator<Item = T>,
FF: FnMut(T, T) -> T
{ // This function could be replaced with `it.next().ok_or(None)`, // but half the useful tree_fold1 work is combining adjacent items, // so put that in a form that LLVM is more likely to optimize well.
let a = iflet Some(v) = it.next() { v } else { return Err(None) }; let b = iflet Some(v) = it.next() { v } else { return Err(Some(a)) };
Ok(f(a, b))
}
fn inner<T, II, FF>(stop: usize, it: &mut II, f: &mut FF) -> State<T> where
II: Iterator<Item = T>,
FF: FnMut(T, T) -> T
{ letmut x = inner0(it, f)?; for height in0..stop { // Try to get another tree the same size with which to combine it, // creating a new tree that's twice as big for next time around. let next = if height == 0 {
inner0(it, f)
} else {
inner(height, it, f)
}; match next {
Ok(y) => x = f(x, y),
// If we ran out of items, combine whatever we did manage // to get. It's better combined with the current value // than something in a parent frame, because the tree in // the parent is always as least as big as this one.
Err(None) => return Err(Some(x)),
Err(Some(y)) => return Err(Some(f(x, y))),
}
}
Ok(x)
}
/// An iterator method that applies a function, producing a single, final value. /// /// `fold_while()` is basically equivalent to [`Iterator::fold`] but with additional support for /// early exit via short-circuiting. /// /// ``` /// use itertools::Itertools; /// use itertools::FoldWhile::{Continue, Done}; /// /// let numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]; /// /// let mut result = 0; /// /// // for loop: /// for i in &numbers { /// if *i > 5 { /// break; /// } /// result = result + i; /// } /// /// // fold: /// let result2 = numbers.iter().fold(0, |acc, x| { /// if *x > 5 { acc } else { acc + x } /// }); /// /// // fold_while: /// let result3 = numbers.iter().fold_while(0, |acc, x| { /// if *x > 5 { Done(acc) } else { Continue(acc + x) } /// }).into_inner(); /// /// // they're the same /// assert_eq!(result, result2); /// assert_eq!(result2, result3); /// ``` /// /// The big difference between the computations of `result2` and `result3` is that while /// `fold()` called the provided closure for every item of the callee iterator, /// `fold_while()` actually stopped iterating as soon as it encountered `Fold::Done(_)`. fn fold_while<B, F>(&mutself, init: B, mut f: F) -> FoldWhile<B> whereSelf: Sized,
F: FnMut(B, Self::Item) -> FoldWhile<B>
{ use Result::{
Ok asContinue,
Err asBreak,
};
let result = self.try_fold(init, #[inline(always)] |acc, v| match f(acc, v) {
FoldWhile::Continue(acc) => Continue(acc),
FoldWhile::Done(acc) => Break(acc),
}
);
match result { Continue(acc) => FoldWhile::Continue(acc), Break(acc) => FoldWhile::Done(acc),
}
}
/// Iterate over the entire iterator and add all the elements. /// /// An empty iterator returns `None`, otherwise `Some(sum)`. /// /// # Panics /// /// When calling `sum1()` and a primitive integer type is being returned, this /// method will panic if the computation overflows and debug assertions are /// enabled. /// /// # Examples /// /// ``` /// use itertools::Itertools; /// /// let empty_sum = (1..1).sum1::<i32>(); /// assert_eq!(empty_sum, None); /// /// let nonempty_sum = (1..11).sum1::<i32>(); /// assert_eq!(nonempty_sum, Some(55)); /// ``` fn sum1<S>(mutself) -> Option<S> whereSelf: Sized,
S: std::iter::Sum<Self::Item>,
{ self.next()
.map(|first| once(first).chain(self).sum())
}
/// Iterate over the entire iterator and multiply all the elements. /// /// An empty iterator returns `None`, otherwise `Some(product)`. /// /// # Panics /// /// When calling `product1()` and a primitive integer type is being returned, /// method will panic if the computation overflows and debug assertions are /// enabled. /// /// # Examples /// ``` /// use itertools::Itertools; /// /// let empty_product = (1..1).product1::<i32>(); /// assert_eq!(empty_product, None); /// /// let nonempty_product = (1..11).product1::<i32>(); /// assert_eq!(nonempty_product, Some(3628800)); /// ``` fn product1<P>(mutself) -> Option<P> whereSelf: Sized,
P: std::iter::Product<Self::Item>,
{ self.next()
.map(|first| once(first).chain(self).product())
}
/// Sort all iterator elements into a new iterator in ascending order. /// /// **Note:** This consumes the entire iterator, uses the /// [`slice::sort_unstable`] method and returns the result as a new /// iterator that owns its elements. /// /// The sorted iterator, if directly collected to a `Vec`, is converted /// without any extra copying or allocation cost. /// /// ``` /// use itertools::Itertools; /// /// // sort the letters of the text in ascending order /// let text = "bdacfe"; /// itertools::assert_equal(text.chars().sorted_unstable(), /// "abcdef".chars()); /// ``` #[cfg(feature = "use_alloc")] fn sorted_unstable(self) -> VecIntoIter<Self::Item> whereSelf: Sized, Self::Item: Ord
{ // Use .sort_unstable() directly since it is not quite identical with // .sort_by(Ord::cmp) letmut v = Vec::from_iter(self);
v.sort_unstable();
v.into_iter()
}
/// Sort all iterator elements into a new iterator in ascending order. /// /// **Note:** This consumes the entire iterator, uses the /// [`slice::sort_unstable_by`] method and returns the result as a new /// iterator that owns its elements. /// /// The sorted iterator, if directly collected to a `Vec`, is converted /// without any extra copying or allocation cost. /// /// ``` /// use itertools::Itertools; /// /// // sort people in descending order by age /// let people = vec![("Jane", 20), ("John", 18), ("Jill", 30), ("Jack", 27)]; /// /// let oldest_people_first = people /// .into_iter() /// .sorted_unstable_by(|a, b| Ord::cmp(&b.1, &a.1)) /// .map(|(person, _age)| person); /// /// itertools::assert_equal(oldest_people_first, /// vec!["Jill", "Jack", "Jane", "John"]); /// ``` #[cfg(feature = "use_alloc")] fn sorted_unstable_by<F>(self, cmp: F) -> VecIntoIter<Self::Item> whereSelf: Sized,
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
{ letmut v = Vec::from_iter(self);
v.sort_unstable_by(cmp);
v.into_iter()
}
/// Sort all iterator elements into a new iterator in ascending order. /// /// **Note:** This consumes the entire iterator, uses the /// [`slice::sort_unstable_by_key`] method and returns the result as a new /// iterator that owns its elements. /// /// The sorted iterator, if directly collected to a `Vec`, is converted /// without any extra copying or allocation cost. /// /// ``` /// use itertools::Itertools; /// /// // sort people in descending order by age /// let people = vec![("Jane", 20), ("John", 18), ("Jill", 30), ("Jack", 27)]; /// /// let oldest_people_first = people /// .into_iter() /// .sorted_unstable_by_key(|x| -x.1) /// .map(|(person, _age)| person); /// /// itertools::assert_equal(oldest_people_first, /// vec!["Jill", "Jack", "Jane", "John"]); /// ``` #[cfg(feature = "use_alloc")] fn sorted_unstable_by_key<K, F>(self, f: F) -> VecIntoIter<Self::Item> whereSelf: Sized,
K: Ord,
F: FnMut(&Self::Item) -> K,
{ letmut v = Vec::from_iter(self);
v.sort_unstable_by_key(f);
v.into_iter()
}
/// Sort all iterator elements into a new iterator in ascending order. /// /// **Note:** This consumes the entire iterator, uses the /// [`slice::sort`] method and returns the result as a new /// iterator that owns its elements. /// /// The sorted iterator, if directly collected to a `Vec`, is converted /// without any extra copying or allocation cost. /// /// ``` /// use itertools::Itertools; /// /// // sort the letters of the text in ascending order /// let text = "bdacfe"; /// itertools::assert_equal(text.chars().sorted(), /// "abcdef".chars()); /// ``` #[cfg(feature = "use_alloc")] fn sorted(self) -> VecIntoIter<Self::Item> whereSelf: Sized, Self::Item: Ord
{ // Use .sort() directly since it is not quite identical with // .sort_by(Ord::cmp) letmut v = Vec::from_iter(self);
v.sort();
v.into_iter()
}
/// Sort all iterator elements into a new iterator in ascending order. /// /// **Note:** This consumes the entire iterator, uses the /// [`slice::sort_by`] method and returns the result as a new /// iterator that owns its elements. /// /// The sorted iterator, if directly collected to a `Vec`, is converted /// without any extra copying or allocation cost. /// /// ``` /// use itertools::Itertools; /// /// // sort people in descending order by age /// let people = vec![("Jane", 20), ("John", 18), ("Jill", 30), ("Jack", 27)]; /// /// let oldest_people_first = people /// .into_iter() /// .sorted_by(|a, b| Ord::cmp(&b.1, &a.1)) /// .map(|(person, _age)| person); /// /// itertools::assert_equal(oldest_people_first, /// vec!["Jill", "Jack", "Jane", "John"]); /// ``` #[cfg(feature = "use_alloc")] fn sorted_by<F>(self, cmp: F) -> VecIntoIter<Self::Item> whereSelf: Sized,
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
{ letmut v = Vec::from_iter(self);
v.sort_by(cmp);
v.into_iter()
}
/// Sort all iterator elements into a new iterator in ascending order. /// /// **Note:** This consumes the entire iterator, uses the /// [`slice::sort_by_key`] method and returns the result as a new /// iterator that owns its elements. /// /// The sorted iterator, if directly collected to a `Vec`, is converted /// without any extra copying or allocation cost. /// /// ``` /// use itertools::Itertools; /// /// // sort people in descending order by age /// let people = vec![("Jane", 20), ("John", 18), ("Jill", 30), ("Jack", 27)]; /// /// let oldest_people_first = people /// .into_iter() /// .sorted_by_key(|x| -x.1) /// .map(|(person, _age)| person); /// /// itertools::assert_equal(oldest_people_first, /// vec!["Jill", "Jack", "Jane", "John"]); /// ``` #[cfg(feature = "use_alloc")] fn sorted_by_key<K, F>(self, f: F) -> VecIntoIter<Self::Item> whereSelf: Sized,
K: Ord,
F: FnMut(&Self::Item) -> K,
{ letmut v = Vec::from_iter(self);
v.sort_by_key(f);
v.into_iter()
}
/// Sort all iterator elements into a new iterator in ascending order. The key function is /// called exactly once per key. /// /// **Note:** This consumes the entire iterator, uses the /// [`slice::sort_by_cached_key`] method and returns the result as a new /// iterator that owns its elements. /// /// The sorted iterator, if directly collected to a `Vec`, is converted /// without any extra copying or allocation cost. /// /// ``` /// use itertools::Itertools; /// /// // sort people in descending order by age /// let people = vec![("Jane", 20), ("John", 18), ("Jill", 30), ("Jack", 27)]; /// /// let oldest_people_first = people /// .into_iter() /// .sorted_by_cached_key(|x| -x.1) /// .map(|(person, _age)| person); /// /// itertools::assert_equal(oldest_people_first, /// vec!["Jill", "Jack", "Jane", "John"]); /// ``` #[cfg(feature = "use_alloc")] fn sorted_by_cached_key<K, F>(self, f: F) -> VecIntoIter<Self::Item> where Self: Sized,
K: Ord,
F: FnMut(&Self::Item) -> K,
{ letmut v = Vec::from_iter(self);
v.sort_by_cached_key(f);
v.into_iter()
}
/// Sort the k smallest elements into a new iterator, in ascending order. /// /// **Note:** This consumes the entire iterator, and returns the result /// as a new iterator that owns its elements. If the input contains /// less than k elements, the result is equivalent to `self.sorted()`. /// /// This is guaranteed to use `k * sizeof(Self::Item) + O(1)` memory /// and `O(n log k)` time, with `n` the number of elements in the input. /// /// The sorted iterator, if directly collected to a `Vec`, is converted /// without any extra copying or allocation cost. /// /// **Note:** This is functionally-equivalent to `self.sorted().take(k)` /// but much more efficient. /// /// ``` /// use itertools::Itertools; /// /// // A random permutation of 0..15 /// let numbers = vec![6, 9, 1, 14, 0, 4, 8, 7, 11, 2, 10, 3, 13, 12, 5]; /// /// let five_smallest = numbers /// .into_iter() /// .k_smallest(5); /// /// itertools::assert_equal(five_smallest, 0..5); /// ``` #[cfg(feature = "use_alloc")] fn k_smallest(self, k: usize) -> VecIntoIter<Self::Item> whereSelf: Sized, Self::Item: Ord
{ crate::k_smallest::k_smallest(self, k)
.into_sorted_vec()
.into_iter()
}
/// Collect all iterator elements into one of two /// partitions. Unlike [`Iterator::partition`], each partition may /// have a distinct type. /// /// ``` /// use itertools::{Itertools, Either}; /// /// let successes_and_failures = vec![Ok(1), Err(false), Err(true), Ok(2)]; /// /// let (successes, failures): (Vec<_>, Vec<_>) = successes_and_failures /// .into_iter() /// .partition_map(|r| { /// match r { /// Ok(v) => Either::Left(v), /// Err(v) => Either::Right(v), /// } /// }); /// /// assert_eq!(successes, [1, 2]); /// assert_eq!(failures, [false, true]); /// ``` fn partition_map<A, B, F, L, R>(self, mut predicate: F) -> (A, B) whereSelf: Sized,
F: FnMut(Self::Item) -> Either<L, R>,
A: Default + Extend<L>,
B: Default + Extend<R>,
{ letmut left = A::default(); letmut right = B::default();
/// Partition a sequence of `Result`s into one list of all the `Ok` elements /// and another list of all the `Err` elements. /// /// ``` /// use itertools::Itertools; /// /// let successes_and_failures = vec![Ok(1), Err(false), Err(true), Ok(2)]; /// /// let (successes, failures): (Vec<_>, Vec<_>) = successes_and_failures /// .into_iter() /// .partition_result(); /// /// assert_eq!(successes, [1, 2]); /// assert_eq!(failures, [false, true]); /// ``` fn partition_result<A, B, T, E>(self) -> (A, B) where Self: Iterator<Item = Result<T, E>> + Sized,
A: Default + Extend<T>,
B: Default + Extend<E>,
{ self.partition_map(|r| match r {
Ok(v) => Either::Left(v),
Err(v) => Either::Right(v),
})
}
/// Return a `HashMap` of keys mapped to `Vec`s of values. Keys and values /// are taken from `(Key, Value)` tuple pairs yielded by the input iterator. /// /// Essentially a shorthand for `.into_grouping_map().collect::<Vec<_>>()`. /// /// ``` /// use itertools::Itertools; /// /// let data = vec![(0, 10), (2, 12), (3, 13), (0, 20), (3, 33), (2, 42)]; /// let lookup = data.into_iter().into_group_map(); /// /// assert_eq!(lookup[&0], vec![10, 20]); /// assert_eq!(lookup.get(&1), None); /// assert_eq!(lookup[&2], vec![12, 42]); /// assert_eq!(lookup[&3], vec![13, 33]); /// ``` #[cfg(feature = "use_std")] fn into_group_map<K, V>(self) -> HashMap<K, Vec<V>> whereSelf: Iterator<Item=(K, V)> + Sized,
K: Hash + Eq,
{
group_map::into_group_map(self)
}
/// Return an `Iterator` on a `HashMap`. Keys mapped to `Vec`s of values. The key is specified /// in the closure. /// /// Essentially a shorthand for `.into_grouping_map_by(f).collect::<Vec<_>>()`. /// /// ``` /// use itertools::Itertools; /// use std::collections::HashMap; /// /// let data = vec![(0, 10), (2, 12), (3, 13), (0, 20), (3, 33), (2, 42)]; /// let lookup: HashMap<u32,Vec<(u32, u32)>> = /// data.clone().into_iter().into_group_map_by(|a| a.0); /// /// assert_eq!(lookup[&0], vec![(0,10),(0,20)]); /// assert_eq!(lookup.get(&1), None); /// assert_eq!(lookup[&2], vec![(2,12), (2,42)]); /// assert_eq!(lookup[&3], vec![(3,13), (3,33)]); /// /// assert_eq!( /// data.into_iter() /// .into_group_map_by(|x| x.0) /// .into_iter() /// .map(|(key, values)| (key, values.into_iter().fold(0,|acc, (_,v)| acc + v ))) /// .collect::<HashMap<u32,u32>>()[&0], /// 30, /// ); /// ``` #[cfg(feature = "use_std")] fn into_group_map_by<K, V, F>(self, f: F) -> HashMap<K, Vec<V>> where Self: Iterator<Item=V> + Sized,
K: Hash + Eq,
F: Fn(&V) -> K,
{
group_map::into_group_map_by(self, f)
}
/// Constructs a `GroupingMap` to be used later with one of the efficient /// group-and-fold operations it allows to perform. /// /// The input iterator must yield item in the form of `(K, V)` where the /// value of type `K` will be used as key to identify the groups and the /// value of type `V` as value for the folding operation. /// /// See [`GroupingMap`] for more informations /// on what operations are available. #[cfg(feature = "use_std")] fn into_grouping_map<K, V>(self) -> GroupingMap<Self> whereSelf: Iterator<Item=(K, V)> + Sized,
K: Hash + Eq,
{
grouping_map::new(self)
}
/// Constructs a `GroupingMap` to be used later with one of the efficient /// group-and-fold operations it allows to perform. /// /// The values from this iterator will be used as values for the folding operation /// while the keys will be obtained from the values by calling `key_mapper`. /// /// See [`GroupingMap`] for more informations /// on what operations are available. #[cfg(feature = "use_std")] fn into_grouping_map_by<K, V, F>(self, key_mapper: F) -> GroupingMapBy<Self, F> whereSelf: Iterator<Item=V> + Sized,
K: Hash + Eq,
F: FnMut(&V) -> K
{
grouping_map::new(grouping_map::MapForGrouping::new(self, key_mapper))
}
/// Return all minimum elements of an iterator. /// /// # Examples /// /// ``` /// use itertools::Itertools; /// /// let a: [i32; 0] = []; /// assert_eq!(a.iter().min_set(), Vec::<&i32>::new()); /// /// let a = [1]; /// assert_eq!(a.iter().min_set(), vec![&1]); /// /// let a = [1, 2, 3, 4, 5]; /// assert_eq!(a.iter().min_set(), vec![&1]); /// /// let a = [1, 1, 1, 1]; /// assert_eq!(a.iter().min_set(), vec![&1, &1, &1, &1]); /// ``` /// /// The elements can be floats but no particular result is guaranteed /// if an element is NaN. #[cfg(feature = "use_std")] fn min_set(self) -> Vec<Self::Item> whereSelf: Sized, Self::Item: Ord
{
extrema_set::min_set_impl(self, |_| (), |x, y, _, _| x.cmp(y))
}
/// Return all minimum elements of an iterator, as determined by /// the specified function. /// /// # Examples /// /// ``` /// # use std::cmp::Ordering; /// use itertools::Itertools; /// /// let a: [(i32, i32); 0] = []; /// assert_eq!(a.iter().min_set_by(|_, _| Ordering::Equal), Vec::<&(i32, i32)>::new()); /// /// let a = [(1, 2)]; /// assert_eq!(a.iter().min_set_by(|&&(k1,_), &&(k2, _)| k1.cmp(&k2)), vec![&(1, 2)]); /// /// let a = [(1, 2), (2, 2), (3, 9), (4, 8), (5, 9)]; /// assert_eq!(a.iter().min_set_by(|&&(_,k1), &&(_,k2)| k1.cmp(&k2)), vec![&(1, 2), &(2, 2)]); /// /// let a = [(1, 2), (1, 3), (1, 4), (1, 5)]; /// assert_eq!(a.iter().min_set_by(|&&(k1,_), &&(k2, _)| k1.cmp(&k2)), vec![&(1, 2), &(1, 3), &(1, 4), &(1, 5)]); /// ``` /// /// The elements can be floats but no particular result is guaranteed /// if an element is NaN. #[cfg(feature = "use_std")] fn min_set_by<F>(self, mut compare: F) -> Vec<Self::Item> whereSelf: Sized, F: FnMut(&Self::Item, &>Self::Item) -> Ordering
{
extrema_set::min_set_impl( self,
|_| (),
|x, y, _, _| compare(x, y)
)
}
/// Return all minimum elements of an iterator, as determined by /// the specified function. /// /// # Examples /// /// ``` /// use itertools::Itertools; /// /// let a: [(i32, i32); 0] = []; /// assert_eq!(a.iter().min_set_by_key(|_| ()), Vec::<&(i32, i32)>::new()); /// /// let a = [(1, 2)]; /// assert_eq!(a.iter().min_set_by_key(|&&(k,_)| k), vec![&(1, 2)]); /// /// let a = [(1, 2), (2, 2), (3, 9), (4, 8), (5, 9)]; /// assert_eq!(a.iter().min_set_by_key(|&&(_, k)| k), vec![&(1, 2), &(2, 2)]); /// /// let a = [(1, 2), (1, 3), (1, 4), (1, 5)]; /// assert_eq!(a.iter().min_set_by_key(|&&(k, _)| k), vec![&(1, 2), &(1, 3), &(1, 4), &(1, 5)]); /// ``` /// /// The elements can be floats but no particular result is guaranteed /// if an element is NaN. #[cfg(feature = "use_std")] fn min_set_by_key<K, F>(self, key: F) -> Vec<Self::Item> whereSelf: Sized, K: Ord, F: FnMut(&Self::Item) -> K
{
extrema_set::min_set_impl(self, key, |_, _, kx, ky| kx.cmp(ky))
}
/// Return all maximum elements of an iterator. /// /// # Examples /// /// ``` /// use itertools::Itertools; /// /// let a: [i32; 0] = []; /// assert_eq!(a.iter().max_set(), Vec::<&i32>::new()); /// /// let a = [1]; /// assert_eq!(a.iter().max_set(), vec![&1]); /// /// let a = [1, 2, 3, 4, 5]; /// assert_eq!(a.iter().max_set(), vec![&5]); /// /// let a = [1, 1, 1, 1]; /// assert_eq!(a.iter().max_set(), vec![&1, &1, &1, &1]); /// ``` /// /// The elements can be floats but no particular result is guaranteed /// if an element is NaN. #[cfg(feature = "use_std")] fn max_set(self) -> Vec<Self::Item> whereSelf: Sized, Self::Item: Ord
{
extrema_set::max_set_impl(self, |_| (), |x, y, _, _| x.cmp(y))
}
/// Return all maximum elements of an iterator, as determined by /// the specified function. /// /// # Examples /// /// ``` /// # use std::cmp::Ordering; /// use itertools::Itertools; /// /// let a: [(i32, i32); 0] = []; /// assert_eq!(a.iter().max_set_by(|_, _| Ordering::Equal), Vec::<&(i32, i32)>::new()); /// /// let a = [(1, 2)]; /// assert_eq!(a.iter().max_set_by(|&&(k1,_), &&(k2, _)| k1.cmp(&k2)), vec![&(1, 2)]); /// /// let a = [(1, 2), (2, 2), (3, 9), (4, 8), (5, 9)]; /// assert_eq!(a.iter().max_set_by(|&&(_,k1), &&(_,k2)| k1.cmp(&k2)), vec![&(3, 9), &(5, 9)]); /// /// let a = [(1, 2), (1, 3), (1, 4), (1, 5)]; /// assert_eq!(a.iter().max_set_by(|&&(k1,_), &&(k2, _)| k1.cmp(&k2)), vec![&(1, 2), &(1, 3), &(1, 4), &(1, 5)]); /// ``` /// /// The elements can be floats but no particular result is guaranteed /// if an element is NaN. #[cfg(feature = "use_std")] fn max_set_by<F>(self, mut compare: F) -> Vec<Self::Item> whereSelf: Sized, F: FnMut(&Self::Item, &>Self::Item) -> Ordering
{
extrema_set::max_set_impl( self,
|_| (),
|x, y, _, _| compare(x, y)
)
}
/// Return all minimum elements of an iterator, as determined by /// the specified function. /// /// # Examples /// /// ``` /// use itertools::Itertools; /// /// let a: [(i32, i32); 0] = []; /// assert_eq!(a.iter().max_set_by_key(|_| ()), Vec::<&(i32, i32)>::new()); /// /// let a = [(1, 2)]; /// assert_eq!(a.iter().max_set_by_key(|&&(k,_)| k), vec![&(1, 2)]); /// /// let a = [(1, 2), (2, 2), (3, 9), (4, 8), (5, 9)]; /// assert_eq!(a.iter().max_set_by_key(|&&(_, k)| k), vec![&(3, 9), &(5, 9)]); /// /// let a = [(1, 2), (1, 3), (1, 4), (1, 5)]; /// assert_eq!(a.iter().max_set_by_key(|&&(k, _)| k), vec![&(1, 2), &(1, 3), &(1, 4), &(1, 5)]); /// ``` /// /// The elements can be floats but no particular result is guaranteed /// if an element is NaN. #[cfg(feature = "use_std")] fn max_set_by_key<K, F>(self, key: F) -> Vec<Self::Item> whereSelf: Sized, K: Ord, F: FnMut(&Self::Item) -> K
{
extrema_set::max_set_impl(self, key, |_, _, kx, ky| kx.cmp(ky))
}
/// Return the minimum and maximum elements in the iterator. /// /// The return type `MinMaxResult` is an enum of three variants: /// /// - `NoElements` if the iterator is empty. /// - `OneElement(x)` if the iterator has exactly one element. /// - `MinMax(x, y)` is returned otherwise, where `x <= y`. Two /// values are equal if and only if there is more than one /// element in the iterator and all elements are equal. /// /// On an iterator of length `n`, `minmax` does `1.5 * n` comparisons, /// and so is faster than calling `min` and `max` separately which does /// `2 * n` comparisons. /// /// # Examples /// /// ``` /// use itertools::Itertools; /// use itertools::MinMaxResult::{NoElements, OneElement, MinMax}; /// /// let a: [i32; 0] = []; /// assert_eq!(a.iter().minmax(), NoElements); /// /// let a = [1]; /// assert_eq!(a.iter().minmax(), OneElement(&1)); /// /// let a = [1, 2, 3, 4, 5]; /// assert_eq!(a.iter().minmax(), MinMax(&1, &5)); /// /// let a = [1, 1, 1, 1]; /// assert_eq!(a.iter().minmax(), MinMax(&1, &1)); /// ``` /// /// The elements can be floats but no particular result is guaranteed /// if an element is NaN. fn minmax(self) -> MinMaxResult<Self::Item> whereSelf: Sized, Self::Item: PartialOrd
{
minmax::minmax_impl(self, |_| (), |x, y, _, _| x < y)
}
/// Return the minimum and maximum element of an iterator, as determined by /// the specified function. /// /// The return value is a variant of [`MinMaxResult`] like for [`.minmax()`](Itertools::minmax). /// /// For the minimum, the first minimal element is returned. For the maximum, /// the last maximal element wins. This matches the behavior of the standard /// [`Iterator::min`] and [`Iterator::max`] methods. /// /// The keys can be floats but no particular result is guaranteed /// if a key is NaN. fn minmax_by_key<K, F>(self, key: F) -> MinMaxResult<Self::Item> whereSelf: Sized, K: PartialOrd, F: FnMut(&Self::Item) -> K
{
minmax::minmax_impl(self, key, |_, _, xk, yk| xk < yk)
}
/// Return the minimum and maximum element of an iterator, as determined by /// the specified comparison function. /// /// The return value is a variant of [`MinMaxResult`] like for [`.minmax()`](Itertools::minmax). /// /// For the minimum, the first minimal element is returned. For the maximum, /// the last maximal element wins. This matches the behavior of the standard /// [`Iterator::min`] and [`Iterator::max`] methods. fn minmax_by<F>(self, mut compare: F) -> MinMaxResult<Self::Item> whereSelf: Sized, F: FnMut(&Self::Item, &>Self::Item) -> Ordering
{
minmax::minmax_impl( self,
|_| (),
|x, y, _, _| Ordering::Less == compare(x, y)
)
}
/// Return the position of the maximum element in the iterator. /// /// If several elements are equally maximum, the position of the /// last of them is returned. /// /// # Examples /// /// ``` /// use itertools::Itertools; /// /// let a: [i32; 0] = []; /// assert_eq!(a.iter().position_max(), None); /// /// let a = [-3, 0, 1, 5, -10]; /// assert_eq!(a.iter().position_max(), Some(3)); /// /// let a = [1, 1, -1, -1]; /// assert_eq!(a.iter().position_max(), Some(1)); /// ``` fn position_max(self) -> Option<usize> whereSelf: Sized, Self::Item: Ord
{ self.enumerate()
.max_by(|x, y| Ord::cmp(&x.1, &y.1))
.map(|x| x.0)
}
/// Return the position of the maximum element in the iterator, as /// determined by the specified function. /// /// If several elements are equally maximum, the position of the /// last of them is returned. /// /// # Examples /// /// ``` /// use itertools::Itertools; /// /// let a: [i32; 0] = []; /// assert_eq!(a.iter().position_max_by_key(|x| x.abs()), None); /// /// let a = [-3_i32, 0, 1, 5, -10]; /// assert_eq!(a.iter().position_max_by_key(|x| x.abs()), Some(4)); /// /// let a = [1_i32, 1, -1, -1]; /// assert_eq!(a.iter().position_max_by_key(|x| x.abs()), Some(3)); /// ``` fn position_max_by_key<K, F>(self, mut key: F) -> Option<usize> whereSelf: Sized, K: Ord, F: FnMut(&Self::Item) -> K
{ self.enumerate()
.max_by(|x, y| Ord::cmp(&key(&x.1), &key(&y.1)))
.map(|x| x.0)
}
/// Return the position of the maximum element in the iterator, as /// determined by the specified comparison function. /// /// If several elements are equally maximum, the position of the /// last of them is returned. /// /// # Examples /// /// ``` /// use itertools::Itertools; /// /// let a: [i32; 0] = []; /// assert_eq!(a.iter().position_max_by(|x, y| x.cmp(y)), None); /// /// let a = [-3_i32, 0, 1, 5, -10]; /// assert_eq!(a.iter().position_max_by(|x, y| x.cmp(y)), Some(3)); /// /// let a = [1_i32, 1, -1, -1]; /// assert_eq!(a.iter().position_max_by(|x, y| x.cmp(y)), Some(1)); /// ``` fn position_max_by<F>(self, mut compare: F) -> Option<usize> whereSelf: Sized, F: FnMut(&Self::Item, &>Self::Item) -> Ordering
{ self.enumerate()
.max_by(|x, y| compare(&x.1, &y.1))
.map(|x| x.0)
}
/// Return the position of the minimum element in the iterator. /// /// If several elements are equally minimum, the position of the /// first of them is returned. /// /// # Examples /// /// ``` /// use itertools::Itertools; /// /// let a: [i32; 0] = []; /// assert_eq!(a.iter().position_min(), None); /// /// let a = [-3, 0, 1, 5, -10]; /// assert_eq!(a.iter().position_min(), Some(4)); /// /// let a = [1, 1, -1, -1]; /// assert_eq!(a.iter().position_min(), Some(2)); /// ``` fn position_min(self) -> Option<usize> whereSelf: Sized, Self::Item: Ord
{ self.enumerate()
.min_by(|x, y| Ord::cmp(&x.1, &y.1))
.map(|x| x.0)
}
/// Return the position of the minimum element in the iterator, as /// determined by the specified function. /// /// If several elements are equally minimum, the position of the /// first of them is returned. /// /// # Examples /// /// ``` /// use itertools::Itertools; /// /// let a: [i32; 0] = []; /// assert_eq!(a.iter().position_min_by_key(|x| x.abs()), None); /// /// let a = [-3_i32, 0, 1, 5, -10]; /// assert_eq!(a.iter().position_min_by_key(|x| x.abs()), Some(1)); /// /// let a = [1_i32, 1, -1, -1]; /// assert_eq!(a.iter().position_min_by_key(|x| x.abs()), Some(0)); /// ``` fn position_min_by_key<K, F>(self, mut key: F) -> Option<usize> whereSelf: Sized, K: Ord, F: FnMut(&Self::Item) -> K
{ self.enumerate()
.min_by(|x, y| Ord::cmp(&key(&x.1), &key(&y.1)))
.map(|x| x.0)
}
/// Return the position of the minimum element in the iterator, as /// determined by the specified comparison function. /// /// If several elements are equally minimum, the position of the /// first of them is returned. /// /// # Examples /// /// ``` /// use itertools::Itertools; /// /// let a: [i32; 0] = []; /// assert_eq!(a.iter().position_min_by(|x, y| x.cmp(y)), None); /// /// let a = [-3_i32, 0, 1, 5, -10]; /// assert_eq!(a.iter().position_min_by(|x, y| x.cmp(y)), Some(4)); /// /// let a = [1_i32, 1, -1, -1]; /// assert_eq!(a.iter().position_min_by(|x, y| x.cmp(y)), Some(2)); /// ``` fn position_min_by<F>(self, mut compare: F) -> Option<usize> whereSelf: Sized, F: FnMut(&Self::Item, &>Self::Item) -> Ordering
{ self.enumerate()
.min_by(|x, y| compare(&x.1, &y.1))
.map(|x| x.0)
}
/// Return the positions of the minimum and maximum elements in /// the iterator. /// /// The return type [`MinMaxResult`] is an enum of three variants: /// /// - `NoElements` if the iterator is empty. /// - `OneElement(xpos)` if the iterator has exactly one element. /// - `MinMax(xpos, ypos)` is returned otherwise, where the /// element at `xpos` ≤ the element at `ypos`. While the /// referenced elements themselves may be equal, `xpos` cannot /// be equal to `ypos`. /// /// On an iterator of length `n`, `position_minmax` does `1.5 * n` /// comparisons, and so is faster than calling `position_min` and /// `position_max` separately which does `2 * n` comparisons. /// /// For the minimum, if several elements are equally minimum, the /// position of the first of them is returned. For the maximum, if /// several elements are equally maximum, the position of the last /// of them is returned. /// /// The elements can be floats but no particular result is /// guaranteed if an element is NaN. /// /// # Examples /// /// ``` /// use itertools::Itertools; /// use itertools::MinMaxResult::{NoElements, OneElement, MinMax}; /// /// let a: [i32; 0] = []; /// assert_eq!(a.iter().position_minmax(), NoElements); /// /// let a = [10]; /// assert_eq!(a.iter().position_minmax(), OneElement(0)); /// /// let a = [-3, 0, 1, 5, -10]; /// assert_eq!(a.iter().position_minmax(), MinMax(4, 3)); /// /// let a = [1, 1, -1, -1]; /// assert_eq!(a.iter().position_minmax(), MinMax(2, 1)); /// ``` fn position_minmax(self) -> MinMaxResult<usize> whereSelf: Sized, Self::Item: PartialOrd
{ usecrate::MinMaxResult::{NoElements, OneElement, MinMax}; match minmax::minmax_impl(self.enumerate(), |_| (), |x, y, _, _| x.1 < y.1) {
NoElements => NoElements,
OneElement(x) => OneElement(x.0),
MinMax(x, y) => MinMax(x.0, y.0),
}
}
/// Return the postions of the minimum and maximum elements of an /// iterator, as determined by the specified function. /// /// The return value is a variant of [`MinMaxResult`] like for /// [`position_minmax`]. /// /// For the minimum, if several elements are equally minimum, the /// position of the first of them is returned. For the maximum, if /// several elements are equally maximum, the position of the last /// of them is returned. /// /// The keys can be floats but no particular result is guaranteed /// if a key is NaN. /// /// # Examples /// /// ``` /// use itertools::Itertools; /// use itertools::MinMaxResult::{NoElements, OneElement, MinMax}; /// /// let a: [i32; 0] = []; /// assert_eq!(a.iter().position_minmax_by_key(|x| x.abs()), NoElements); /// /// let a = [10_i32]; /// assert_eq!(a.iter().position_minmax_by_key(|x| x.abs()), OneElement(0)); /// /// let a = [-3_i32, 0, 1, 5, -10]; /// assert_eq!(a.iter().position_minmax_by_key(|x| x.abs()), MinMax(1, 4)); /// /// let a = [1_i32, 1, -1, -1]; /// assert_eq!(a.iter().position_minmax_by_key(|x| x.abs()), MinMax(0, 3)); /// ``` /// /// [`position_minmax`]: Self::position_minmax fn position_minmax_by_key<K, F>(self, mut key: F) -> MinMaxResult<usize> whereSelf: Sized, K: PartialOrd, F: FnMut(&Self::Item) -> K
{ usecrate::MinMaxResult::{NoElements, OneElement, MinMax}; matchself.enumerate().minmax_by_key(|e| key(&e.1)) {
NoElements => NoElements,
OneElement(x) => OneElement(x.0),
MinMax(x, y) => MinMax(x.0, y.0),
}
}
/// Return the postions of the minimum and maximum elements of an /// iterator, as determined by the specified comparison function. /// /// The return value is a variant of [`MinMaxResult`] like for /// [`position_minmax`]. /// /// For the minimum, if several elements are equally minimum, the /// position of the first of them is returned. For the maximum, if /// several elements are equally maximum, the position of the last /// of them is returned. /// /// # Examples /// /// ``` /// use itertools::Itertools; /// use itertools::MinMaxResult::{NoElements, OneElement, MinMax}; /// /// let a: [i32; 0] = []; /// assert_eq!(a.iter().position_minmax_by(|x, y| x.cmp(y)), NoElements); /// /// let a = [10_i32]; /// assert_eq!(a.iter().position_minmax_by(|x, y| x.cmp(y)), OneElement(0)); /// /// let a = [-3_i32, 0, 1, 5, -10]; /// assert_eq!(a.iter().position_minmax_by(|x, y| x.cmp(y)), MinMax(4, 3)); /// /// let a = [1_i32, 1, -1, -1]; /// assert_eq!(a.iter().position_minmax_by(|x, y| x.cmp(y)), MinMax(2, 1)); /// ``` /// /// [`position_minmax`]: Self::position_minmax fn position_minmax_by<F>(self, mut compare: F) -> MinMaxResult<usize> whereSelf: Sized, F: FnMut(&Self::Item, &>Self::Item) -> Ordering
{ usecrate::MinMaxResult::{NoElements, OneElement, MinMax}; matchself.enumerate().minmax_by(|x, y| compare(&x.1, &y.yle='color: green'>1)) {
NoElements => NoElements,
OneElement(x) => OneElement(x.0),
MinMax(x, y) => MinMax(x.0, y.0),
}
}
/// If the iterator yields exactly one element, that element will be returned, otherwise /// an error will be returned containing an iterator that has the same output as the input /// iterator. /// /// This provides an additional layer of validation over just calling `Iterator::next()`. /// If your assumption that there should only be one element yielded is false this provides /// the opportunity to detect and handle that, preventing errors at a distance. /// /// # Examples /// ``` /// use itertools::Itertools; /// /// assert_eq!((0..10).filter(|&x| x == 2).exactly_one().unwrap(), 2); /// assert!((0..10).filter(|&x| x > 1 && x < 4).exactly_one().unwrap_err().eq(2..4)); /// assert!((0..10).filter(|&x| x > 1 && x < 5).exactly_one().unwrap_err().eq(2..5)); /// assert!((0..10).filter(|&_| false).exactly_one().unwrap_err().eq(0..0)); /// ``` fn exactly_one(mutself) -> Result<Self::Item, ExactlyOneError<Self>> where Self: Sized,
{ matchself.next() {
Some(first) => { matchself.next() {
Some(second) => {
Err(ExactlyOneError::new(Some(Either::Left([first, second])), self))
}
None => {
Ok(first)
}
}
}
None => Err(ExactlyOneError::new(None, self)),
}
}
/// If the iterator yields no elements, Ok(None) will be returned. If the iterator yields /// exactly one element, that element will be returned, otherwise an error will be returned /// containing an iterator that has the same output as the input iterator. /// /// This provides an additional layer of validation over just calling `Iterator::next()`. /// If your assumption that there should be at most one element yielded is false this provides /// the opportunity to detect and handle that, preventing errors at a distance. /// /// # Examples /// ``` /// use itertools::Itertools; /// /// assert_eq!((0..10).filter(|&x| x == 2).at_most_one().unwrap(), Some(2)); /// assert!((0..10).filter(|&x| x > 1 && x < 4).at_most_one().unwrap_err().eq(2..4)); /// assert!((0..10).filter(|&x| x > 1 && x < 5).at_most_one().unwrap_err().eq(2..5)); /// assert_eq!((0..10).filter(|&_| false).at_most_one().unwrap(), None); /// ``` fn at_most_one(mutself) -> Result<Option<Self::Item>, ExactlyOneError<Self>> where Self: Sized,
{ matchself.next() {
Some(first) => { matchself.next() {
Some(second) => {
Err(ExactlyOneError::new(Some(Either::Left([first, second])), self))
}
None => {
Ok(Some(first))
}
}
}
None => Ok(None),
}
}
/// An iterator adaptor that allows the user to peek at multiple `.next()` /// values without advancing the base iterator. /// /// # Examples /// ``` /// use itertools::Itertools; /// /// let mut iter = (0..10).multipeek(); /// assert_eq!(iter.peek(), Some(&0)); /// assert_eq!(iter.peek(), Some(&1)); /// assert_eq!(iter.peek(), Some(&2)); /// assert_eq!(iter.next(), Some(0)); /// assert_eq!(iter.peek(), Some(&1)); /// ``` #[cfg(feature = "use_alloc")] fn multipeek(self) -> MultiPeek<Self> where Self: Sized,
{
multipeek_impl::multipeek(self)
}
/// Collect the items in this iterator and return a `HashMap` which /// contains each item that appears in the iterator and the number /// of times it appears. /// /// # Examples /// ``` /// # use itertools::Itertools; /// let counts = [1, 1, 1, 3, 3, 5].into_iter().counts(); /// assert_eq!(counts[&1], 3); /// assert_eq!(counts[&3], 2); /// assert_eq!(counts[&5], 1); /// assert_eq!(counts.get(&0), None); /// ``` #[cfg(feature = "use_std")] fn counts(self) -> HashMap<Self::Item, usize> where Self: Sized, Self::Item: Eq + Hash,
{ letmut counts = HashMap::new(); self.for_each(|item| *counts.entry(item).or_default() += 1);
counts
}
/// Collect the items in this iterator and return a `HashMap` which /// contains each item that appears in the iterator and the number /// of times it appears, /// determining identity using a keying function. /// /// ``` /// # use itertools::Itertools; /// struct Character { /// first_name: &'static str, /// last_name: &'static str, /// } /// /// let characters = /// vec![ /// Character { first_name: "Amy", last_name: "Pond" }, /// Character { first_name: "Amy", last_name: "Wong" }, /// Character { first_name: "Amy", last_name: "Santiago" }, /// Character { first_name: "James", last_name: "Bond" }, /// Character { first_name: "James", last_name: "Sullivan" }, /// Character { first_name: "James", last_name: "Norington" }, /// Character { first_name: "James", last_name: "Kirk" }, /// ]; /// /// let first_name_frequency = /// characters /// .into_iter() /// .counts_by(|c| c.first_name); /// /// assert_eq!(first_name_frequency["Amy"], 3); /// assert_eq!(first_name_frequency["James"], 4); /// assert_eq!(first_name_frequency.contains_key("Asha"), false); /// ``` #[cfg(feature = "use_std")] fn counts_by<K, F>(self, f: F) -> HashMap<K, usize> where Self: Sized,
K: Eq + Hash,
F: FnMut(Self::Item) -> K,
{ self.map(f).counts()
}
/// Converts an iterator of tuples into a tuple of containers. /// /// `unzip()` consumes an entire iterator of n-ary tuples, producing `n` collections, one for each /// column. /// /// This function is, in some sense, the opposite of [`multizip`]. /// /// ``` /// use itertools::Itertools; /// /// let inputs = vec![(1, 2, 3), (4, 5, 6), (7, 8, 9)]; /// /// let (a, b, c): (Vec<_>, Vec<_>, Vec<_>) = inputs /// .into_iter() /// .multiunzip(); /// /// assert_eq!(a, vec![1, 4, 7]); /// assert_eq!(b, vec![2, 5, 8]); /// assert_eq!(c, vec![3, 6, 9]); /// ``` fn multiunzip<FromI>(self) -> FromI where Self: Sized + MultiUnzip<FromI>,
{
MultiUnzip::multiunzip(self)
}
}
impl<T: ?Sized> Itertools for T where T: Iterator { }
/// Return `true` if both iterables produce equal sequences /// (elements pairwise equal and sequences of the same length), /// `false` otherwise. /// /// [`IntoIterator`] enabled version of [`Iterator::eq`]. /// /// ``` /// assert!(itertools::equal(vec![1, 2, 3], 1..4)); /// assert!(!itertools::equal(&[0, 0], &[0, 0, 0])); /// ``` pubfn equal<I, J>(a: I, b: J) -> bool where I: IntoIterator,
J: IntoIterator,
I::Item: PartialEq<J::Item>
{
a.into_iter().eq(b)
}
/// Assert that two iterables produce equal sequences, with the same /// semantics as [`equal(a, b)`](equal). /// /// **Panics** on assertion failure with a message that shows the /// two iteration elements. /// /// ```ignore /// assert_equal("exceed".split('c'), "excess".split('c')); /// // ^PANIC: panicked at 'Failed assertion Some("eed") == Some("ess") for iteration 1', /// ``` pubfn assert_equal<I, J>(a: I, b: J) where I: IntoIterator,
J: IntoIterator,
I::Item: fmt::Debug + PartialEq<J::Item>,
J::Item: fmt::Debug,
{ letmut ia = a.into_iter(); letmut ib = b.into_iter(); letmut i = 0; loop { match (ia.next(), ib.next()) {
(None, None) => return,
(a, b) => { let equal = match (&a, &b) {
(&Some(ref a), &Some(ref b)) => a == b,
_ => false,
};
assert!(equal, "Failed assertion {a:?} == {b:?} for iteration {i}",
i=i, a=a, b=b);
i += 1;
}
}
}
}
/// Partition a sequence using predicate `pred` so that elements /// that map to `true` are placed before elements which map to `false`. /// /// The order within the partitions is arbitrary. /// /// Return the index of the split point. /// /// ``` /// use itertools::partition; /// /// # // use repeated numbers to not promise any ordering /// let mut data = [7, 1, 1, 7, 1, 1, 7]; /// let split_index = partition(&mut data, |elt| *elt >= 3); /// /// assert_eq!(data, [7, 7, 7, 1, 1, 1, 1]); /// assert_eq!(split_index, 3); /// ``` pubfn partition<'a, A: 'a, I, F>(iter: I, mut pred: F) -> usize where I: IntoIterator<Item = &'a mut A>,
I::IntoIter: DoubleEndedIterator,
F: FnMut(&A) -> bool
{ letmut split_index = 0; letmut iter = iter.into_iter(); 'main: while let Some(front) = iter.next() { if !pred(front) { loop { match iter.next_back() {
Some(back) => if pred(back) {
std::mem::swap(front, back); break;
},
None => break'main,
}
}
}
split_index += 1;
}
split_index
}
/// An enum used for controlling the execution of `fold_while`. /// /// See [`.fold_while()`](Itertools::fold_while) for more information. #[derive(Copy, Clone, Debug, Eq, PartialEq)] pubenum FoldWhile<T> { /// Continue folding with this value Continue(T), /// Fold is complete and will return this value
Done(T),
}
impl<T> FoldWhile<T> { /// Return the value in the continue or done. pubfn into_inner(self) -> T { matchself {
FoldWhile::Continue(x) | FoldWhile::Done(x) => x,
}
}
/// Return true if `self` is `Done`, false if it is `Continue`. pubfn is_done(&self) -> bool { match *self {
FoldWhile::Continue(_) => false,
FoldWhile::Done(_) => true,
}
}
}
Messung V0.5 in Prozent
¤ Dauer der Verarbeitung: 0.113 Sekunden
(vorverarbeitet am 2026-06-19)
¤
Die Informationen auf dieser Webseite wurden
nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit,
noch Qualität der bereit gestellten Informationen zugesichert.
Bemerkung:
Die farbliche Syntaxdarstellung und die Messung sind noch experimentell.
