| <!DOCTYPE html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1.0"><meta name="generator" content="rustdoc"><meta name="description" content="An [`Iterator`] blanket implementation that provides extra adaptors and methods."><meta name="keywords" content="rust, rustlang, rust-lang, Itertools"><title>Itertools in itertools - Rust</title><link rel="preload" as="font" type="font/woff2" crossorigin href="../SourceSerif4-Regular.ttf.woff2"><link rel="preload" as="font" type="font/woff2" crossorigin href="../FiraSans-Regular.woff2"><link rel="preload" as="font" type="font/woff2" crossorigin href="../FiraSans-Medium.woff2"><link rel="preload" as="font" type="font/woff2" crossorigin href="../SourceCodePro-Regular.ttf.woff2"><link rel="preload" as="font" type="font/woff2" crossorigin href="../SourceSerif4-Bold.ttf.woff2"><link rel="preload" as="font" type="font/woff2" crossorigin href="../SourceCodePro-Semibold.ttf.woff2"><link rel="stylesheet" href="../normalize.css"><link rel="stylesheet" href="../rustdoc.css" id="mainThemeStyle"><link rel="stylesheet" href="../ayu.css" disabled><link rel="stylesheet" href="../dark.css" disabled><link rel="stylesheet" href="../light.css" id="themeStyle"><script id="default-settings" ></script><script src="../storage.js"></script><script defer src="sidebar-items.js"></script><script defer src="../main.js"></script><noscript><link rel="stylesheet" href="../noscript.css"></noscript><link rel="alternate icon" type="image/png" href="../favicon-16x16.png"><link rel="alternate icon" type="image/png" href="../favicon-32x32.png"><link rel="icon" type="image/svg+xml" href="../favicon.svg"></head><body class="rustdoc trait"><!--[if lte IE 11]><div class="warning">This old browser is unsupported and will most likely display funky things.</div><![endif]--><nav class="mobile-topbar"><button class="sidebar-menu-toggle">☰</button><a class="sidebar-logo" href="../itertools/index.html"><div class="logo-container"><img class="rust-logo" src="../rust-logo.svg" alt="logo"></div></a><h2></h2></nav><nav class="sidebar"><a class="sidebar-logo" href="../itertools/index.html"><div class="logo-container"><img class="rust-logo" src="../rust-logo.svg" alt="logo"></div></a><h2 class="location"><a href="#">Itertools</a></h2><div class="sidebar-elems"><section><h3><a href="#provided-methods">Provided Methods</a></h3><ul class="block"><li><a href="#method.all_equal">all_equal</a></li><li><a href="#method.all_unique">all_unique</a></li><li><a href="#method.at_most_one">at_most_one</a></li><li><a href="#method.batching">batching</a></li><li><a href="#method.cartesian_product">cartesian_product</a></li><li><a href="#method.chunks">chunks</a></li><li><a href="#method.circular_tuple_windows">circular_tuple_windows</a></li><li><a href="#method.coalesce">coalesce</a></li><li><a href="#method.collect_tuple">collect_tuple</a></li><li><a href="#method.collect_vec">collect_vec</a></li><li><a href="#method.combinations">combinations</a></li><li><a href="#method.combinations_with_replacement">combinations_with_replacement</a></li><li><a href="#method.concat">concat</a></li><li><a href="#method.contains">contains</a></li><li><a href="#method.counts">counts</a></li><li><a href="#method.counts_by">counts_by</a></li><li><a href="#method.dedup">dedup</a></li><li><a href="#method.dedup_by">dedup_by</a></li><li><a href="#method.dedup_by_with_count">dedup_by_with_count</a></li><li><a href="#method.dedup_with_count">dedup_with_count</a></li><li><a href="#method.dropping">dropping</a></li><li><a href="#method.dropping_back">dropping_back</a></li><li><a href="#method.duplicates">duplicates</a></li><li><a href="#method.duplicates_by">duplicates_by</a></li><li><a href="#method.exactly_one">exactly_one</a></li><li><a href="#method.filter_map_ok">filter_map_ok</a></li><li><a href="#method.filter_ok">filter_ok</a></li><li><a href="#method.find_or_first">find_or_first</a></li><li><a href="#method.find_or_last">find_or_last</a></li><li><a href="#method.find_position">find_position</a></li><li><a href="#method.flatten_ok">flatten_ok</a></li><li><a href="#method.fold1">fold1</a></li><li><a href="#method.fold_ok">fold_ok</a></li><li><a href="#method.fold_options">fold_options</a></li><li><a href="#method.fold_results">fold_results</a></li><li><a href="#method.fold_while">fold_while</a></li><li><a href="#method.foreach">foreach</a></li><li><a href="#method.format">format</a></li><li><a href="#method.format_with">format_with</a></li><li><a href="#method.group_by">group_by</a></li><li><a href="#method.interleave">interleave</a></li><li><a href="#method.interleave_shortest">interleave_shortest</a></li><li><a href="#method.intersperse">intersperse</a></li><li><a href="#method.intersperse_with">intersperse_with</a></li><li><a href="#method.into_group_map">into_group_map</a></li><li><a href="#method.into_group_map_by">into_group_map_by</a></li><li><a href="#method.into_grouping_map">into_grouping_map</a></li><li><a href="#method.into_grouping_map_by">into_grouping_map_by</a></li><li><a href="#method.join">join</a></li><li><a href="#method.k_smallest">k_smallest</a></li><li><a href="#method.kmerge">kmerge</a></li><li><a href="#method.kmerge_by">kmerge_by</a></li><li><a href="#method.map_into">map_into</a></li><li><a href="#method.map_ok">map_ok</a></li><li><a href="#method.map_results">map_results</a></li><li><a href="#method.max_set">max_set</a></li><li><a href="#method.max_set_by">max_set_by</a></li><li><a href="#method.max_set_by_key">max_set_by_key</a></li><li><a href="#method.merge">merge</a></li><li><a href="#method.merge_by">merge_by</a></li><li><a href="#method.merge_join_by">merge_join_by</a></li><li><a href="#method.min_set">min_set</a></li><li><a href="#method.min_set_by">min_set_by</a></li><li><a href="#method.min_set_by_key">min_set_by_key</a></li><li><a href="#method.minmax">minmax</a></li><li><a href="#method.minmax_by">minmax_by</a></li><li><a href="#method.minmax_by_key">minmax_by_key</a></li><li><a href="#method.multi_cartesian_product">multi_cartesian_product</a></li><li><a href="#method.multipeek">multipeek</a></li><li><a href="#method.multiunzip">multiunzip</a></li><li><a href="#method.next_tuple">next_tuple</a></li><li><a href="#method.pad_using">pad_using</a></li><li><a href="#method.partition_map">partition_map</a></li><li><a href="#method.partition_result">partition_result</a></li><li><a href="#method.peeking_take_while">peeking_take_while</a></li><li><a href="#method.permutations">permutations</a></li><li><a href="#method.position_max">position_max</a></li><li><a href="#method.position_max_by">position_max_by</a></li><li><a href="#method.position_max_by_key">position_max_by_key</a></li><li><a href="#method.position_min">position_min</a></li><li><a href="#method.position_min_by">position_min_by</a></li><li><a href="#method.position_min_by_key">position_min_by_key</a></li><li><a href="#method.position_minmax">position_minmax</a></li><li><a href="#method.position_minmax_by">position_minmax_by</a></li><li><a href="#method.position_minmax_by_key">position_minmax_by_key</a></li><li><a href="#method.positions">positions</a></li><li><a href="#method.powerset">powerset</a></li><li><a href="#method.product1">product1</a></li><li><a href="#method.set_from">set_from</a></li><li><a href="#method.sorted">sorted</a></li><li><a href="#method.sorted_by">sorted_by</a></li><li><a href="#method.sorted_by_cached_key">sorted_by_cached_key</a></li><li><a href="#method.sorted_by_key">sorted_by_key</a></li><li><a href="#method.sorted_unstable">sorted_unstable</a></li><li><a href="#method.sorted_unstable_by">sorted_unstable_by</a></li><li><a href="#method.sorted_unstable_by_key">sorted_unstable_by_key</a></li><li><a href="#method.step">step</a></li><li><a href="#method.sum1">sum1</a></li><li><a href="#method.take_while_ref">take_while_ref</a></li><li><a href="#method.tee">tee</a></li><li><a href="#method.tree_fold1">tree_fold1</a></li><li><a href="#method.try_collect">try_collect</a></li><li><a href="#method.tuple_combinations">tuple_combinations</a></li><li><a href="#method.tuple_windows">tuple_windows</a></li><li><a href="#method.tuples">tuples</a></li><li><a href="#method.unique">unique</a></li><li><a href="#method.unique_by">unique_by</a></li><li><a href="#method.update">update</a></li><li><a href="#method.while_some">while_some</a></li><li><a href="#method.with_position">with_position</a></li><li><a href="#method.zip_eq">zip_eq</a></li><li><a href="#method.zip_longest">zip_longest</a></li></ul><h3><a href="#implementors">Implementors</a></h3></section><h2><a href="index.html">In itertools</a></h2></div></nav><main><div class="width-limiter"><nav class="sub"><form class="search-form"><div class="search-container"><span></span><input class="search-input" name="search" autocomplete="off" spellcheck="false" placeholder="Click or press ‘S’ to search, ‘?’ for more options…" type="search"><div id="help-button" title="help" tabindex="-1"><a href="../help.html">?</a></div><div id="settings-menu" tabindex="-1"><a href="../settings.html" title="settings"><img width="22" height="22" alt="Change settings" src="../wheel.svg"></a></div></div></form></nav><section id="main-content" class="content"><div class="main-heading"><h1 class="fqn">Trait <a href="index.html">itertools</a>::<wbr><a class="trait" href="#">Itertools</a><button id="copy-path" onclick="copy_path(this)" title="Copy item path to clipboard"><img src="../clipboard.svg" width="19" height="18" alt="Copy item path"></button></h1><span class="out-of-band"><a class="srclink" href="../src/itertools/lib.rs.html#431-3660">source</a> · <a id="toggle-all-docs" href="javascript:void(0)" title="collapse all docs">[<span class="inner">−</span>]</a></span></div><div class="item-decl"><pre class="rust trait"><code>pub trait Itertools: Iterator { |
| <details class="rustdoc-toggle type-contents-toggle"><summary class="hideme"><span>Show 112 methods</span></summary> fn <a href="#method.interleave" class="fnname">interleave</a><J>(self, other: J) -> <a class="struct" href="structs/struct.Interleave.html" title="struct itertools::structs::Interleave">Interleave</a><Self, J::IntoIter><span class="notable-traits"><span class="notable-traits-tooltip">ⓘ<span class="notable-traits-tooltiptext"><span class="docblock"><span class="notable">Notable traits for <a class="struct" href="structs/struct.Interleave.html" title="struct itertools::structs::Interleave">Interleave</a><I, J></span><code class="content"><span class="where fmt-newline">impl<I, J> Iterator for <a class="struct" href="structs/struct.Interleave.html" title="struct itertools::structs::Interleave">Interleave</a><I, J><span class="where fmt-newline">where<br> I: Iterator,<br> J: Iterator<Item = I::Item>,</span></span><span class="where fmt-newline"> type <a class="associatedtype">Item</a> = I::Item;</span></code></span></span></span></span><br> <span class="where">where<br> J: IntoIterator<Item = Self::Item>,<br> Self: Sized</span>, |
| { ... } |
| <span class="item-spacer"></span> fn <a href="#method.interleave_shortest" class="fnname">interleave_shortest</a><J>(<br> self,<br> other: J<br> ) -> <a class="struct" href="structs/struct.InterleaveShortest.html" title="struct itertools::structs::InterleaveShortest">InterleaveShortest</a><Self, J::IntoIter><span class="notable-traits"><span class="notable-traits-tooltip">ⓘ<span class="notable-traits-tooltiptext"><span class="docblock"><span class="notable">Notable traits for <a class="struct" href="structs/struct.InterleaveShortest.html" title="struct itertools::structs::InterleaveShortest">InterleaveShortest</a><I, J></span><code class="content"><span class="where fmt-newline">impl<I, J> Iterator for <a class="struct" href="structs/struct.InterleaveShortest.html" title="struct itertools::structs::InterleaveShortest">InterleaveShortest</a><I, J><span class="where fmt-newline">where<br> I: Iterator,<br> J: Iterator<Item = I::Item>,</span></span><span class="where fmt-newline"> type <a class="associatedtype">Item</a> = I::Item;</span></code></span></span></span></span><br> <span class="where">where<br> J: IntoIterator<Item = Self::Item>,<br> Self: Sized</span>, |
| { ... } |
| <span class="item-spacer"></span> fn <a href="#method.intersperse" class="fnname">intersperse</a>(self, element: Self::Item) -> <a class="type" href="structs/type.Intersperse.html" title="type itertools::structs::Intersperse">Intersperse</a><Self><br> <span class="where">where<br> Self: Sized,<br> Self::Item: Clone</span>, |
| { ... } |
| <span class="item-spacer"></span> fn <a href="#method.intersperse_with" class="fnname">intersperse_with</a><F>(self, element: F) -> <a class="struct" href="structs/struct.IntersperseWith.html" title="struct itertools::structs::IntersperseWith">IntersperseWith</a><Self, F><span class="notable-traits"><span class="notable-traits-tooltip">ⓘ<span class="notable-traits-tooltiptext"><span class="docblock"><span class="notable">Notable traits for <a class="struct" href="structs/struct.IntersperseWith.html" title="struct itertools::structs::IntersperseWith">IntersperseWith</a><I, ElemF></span><code class="content"><span class="where fmt-newline">impl<I, ElemF> Iterator for <a class="struct" href="structs/struct.IntersperseWith.html" title="struct itertools::structs::IntersperseWith">IntersperseWith</a><I, ElemF><span class="where fmt-newline">where<br> I: Iterator,<br> ElemF: IntersperseElement<I::Item>,</span></span><span class="where fmt-newline"> type <a class="associatedtype">Item</a> = I::Item;</span></code></span></span></span></span><br> <span class="where">where<br> Self: Sized,<br> F: FnMut() -> Self::Item</span>, |
| { ... } |
| <span class="item-spacer"></span> fn <a href="#method.zip_longest" class="fnname">zip_longest</a><J>(self, other: J) -> <a class="struct" href="structs/struct.ZipLongest.html" title="struct itertools::structs::ZipLongest">ZipLongest</a><Self, J::IntoIter><span class="notable-traits"><span class="notable-traits-tooltip">ⓘ<span class="notable-traits-tooltiptext"><span class="docblock"><span class="notable">Notable traits for <a class="struct" href="structs/struct.ZipLongest.html" title="struct itertools::structs::ZipLongest">ZipLongest</a><T, U></span><code class="content"><span class="where fmt-newline">impl<T, U> Iterator for <a class="struct" href="structs/struct.ZipLongest.html" title="struct itertools::structs::ZipLongest">ZipLongest</a><T, U><span class="where fmt-newline">where<br> T: Iterator,<br> U: Iterator,</span></span><span class="where fmt-newline"> type <a class="associatedtype">Item</a> = <a class="enum" href="enum.EitherOrBoth.html" title="enum itertools::EitherOrBoth">EitherOrBoth</a><T::Item, U::Item>;</span></code></span></span></span></span><br> <span class="where">where<br> J: IntoIterator,<br> Self: Sized</span>, |
| { ... } |
| <span class="item-spacer"></span> fn <a href="#method.zip_eq" class="fnname">zip_eq</a><J>(self, other: J) -> <a class="struct" href="structs/struct.ZipEq.html" title="struct itertools::structs::ZipEq">ZipEq</a><Self, J::IntoIter><span class="notable-traits"><span class="notable-traits-tooltip">ⓘ<span class="notable-traits-tooltiptext"><span class="docblock"><span class="notable">Notable traits for <a class="struct" href="structs/struct.ZipEq.html" title="struct itertools::structs::ZipEq">ZipEq</a><I, J></span><code class="content"><span class="where fmt-newline">impl<I, J> Iterator for <a class="struct" href="structs/struct.ZipEq.html" title="struct itertools::structs::ZipEq">ZipEq</a><I, J><span class="where fmt-newline">where<br> I: Iterator,<br> J: Iterator,</span></span><span class="where fmt-newline"> type <a class="associatedtype">Item</a> = (I::Item, J::Item);</span></code></span></span></span></span><br> <span class="where">where<br> J: IntoIterator,<br> Self: Sized</span>, |
| { ... } |
| <span class="item-spacer"></span> fn <a href="#method.batching" class="fnname">batching</a><B, F>(self, f: F) -> <a class="struct" href="structs/struct.Batching.html" title="struct itertools::structs::Batching">Batching</a><Self, F><span class="notable-traits"><span class="notable-traits-tooltip">ⓘ<span class="notable-traits-tooltiptext"><span class="docblock"><span class="notable">Notable traits for <a class="struct" href="structs/struct.Batching.html" title="struct itertools::structs::Batching">Batching</a><I, F></span><code class="content"><span class="where fmt-newline">impl<B, F, I> Iterator for <a class="struct" href="structs/struct.Batching.html" title="struct itertools::structs::Batching">Batching</a><I, F><span class="where fmt-newline">where<br> I: Iterator,<br> F: FnMut(&mut I) -> Option<B>,</span></span><span class="where fmt-newline"> type <a class="associatedtype">Item</a> = B;</span></code></span></span></span></span><br> <span class="where">where<br> F: FnMut(&mut Self) -> Option<B>,<br> Self: Sized</span>, |
| { ... } |
| <span class="item-spacer"></span> fn <a href="#method.group_by" class="fnname">group_by</a><K, F>(self, key: F) -> <a class="struct" href="structs/struct.GroupBy.html" title="struct itertools::structs::GroupBy">GroupBy</a><K, Self, F><br> <span class="where">where<br> Self: Sized,<br> F: FnMut(&Self::Item) -> K,<br> K: PartialEq</span>, |
| { ... } |
| <span class="item-spacer"></span> fn <a href="#method.chunks" class="fnname">chunks</a>(self, size: usize) -> <a class="struct" href="structs/struct.IntoChunks.html" title="struct itertools::structs::IntoChunks">IntoChunks</a><Self><br> <span class="where">where<br> Self: Sized</span>, |
| { ... } |
| <span class="item-spacer"></span> fn <a href="#method.tuple_windows" class="fnname">tuple_windows</a><T>(self) -> <a class="struct" href="structs/struct.TupleWindows.html" title="struct itertools::structs::TupleWindows">TupleWindows</a><Self, T><span class="notable-traits"><span class="notable-traits-tooltip">ⓘ<span class="notable-traits-tooltiptext"><span class="docblock"><span class="notable">Notable traits for <a class="struct" href="structs/struct.TupleWindows.html" title="struct itertools::structs::TupleWindows">TupleWindows</a><I, T></span><code class="content"><span class="where fmt-newline">impl<I, T> Iterator for <a class="struct" href="structs/struct.TupleWindows.html" title="struct itertools::structs::TupleWindows">TupleWindows</a><I, T><span class="where fmt-newline">where<br> I: Iterator<Item = T::Item>,<br> T: <a class="trait" href="traits/trait.HomogeneousTuple.html" title="trait itertools::traits::HomogeneousTuple">HomogeneousTuple</a> + Clone,<br> T::Item: Clone,</span></span><span class="where fmt-newline"> type <a class="associatedtype">Item</a> = T;</span></code></span></span></span></span><br> <span class="where">where<br> Self: Sized + Iterator<Item = T::Item>,<br> T: <a class="trait" href="traits/trait.HomogeneousTuple.html" title="trait itertools::traits::HomogeneousTuple">HomogeneousTuple</a>,<br> T::Item: Clone</span>, |
| { ... } |
| <span class="item-spacer"></span> fn <a href="#method.circular_tuple_windows" class="fnname">circular_tuple_windows</a><T>(self) -> <a class="struct" href="structs/struct.CircularTupleWindows.html" title="struct itertools::structs::CircularTupleWindows">CircularTupleWindows</a><Self, T><span class="notable-traits"><span class="notable-traits-tooltip">ⓘ<span class="notable-traits-tooltiptext"><span class="docblock"><span class="notable">Notable traits for <a class="struct" href="structs/struct.CircularTupleWindows.html" title="struct itertools::structs::CircularTupleWindows">CircularTupleWindows</a><I, T></span><code class="content"><span class="where fmt-newline">impl<I, T> Iterator for <a class="struct" href="structs/struct.CircularTupleWindows.html" title="struct itertools::structs::CircularTupleWindows">CircularTupleWindows</a><I, T><span class="where fmt-newline">where<br> I: Iterator<Item = T::Item> + Clone,<br> T: TupleCollect + Clone,<br> T::Item: Clone,</span></span><span class="where fmt-newline"> type <a class="associatedtype">Item</a> = T;</span></code></span></span></span></span><br> <span class="where">where<br> Self: Sized + Clone + Iterator<Item = T::Item> + ExactSizeIterator,<br> T: TupleCollect + Clone,<br> T::Item: Clone</span>, |
| { ... } |
| <span class="item-spacer"></span> fn <a href="#method.tuples" class="fnname">tuples</a><T>(self) -> <a class="struct" href="structs/struct.Tuples.html" title="struct itertools::structs::Tuples">Tuples</a><Self, T><span class="notable-traits"><span class="notable-traits-tooltip">ⓘ<span class="notable-traits-tooltiptext"><span class="docblock"><span class="notable">Notable traits for <a class="struct" href="structs/struct.Tuples.html" title="struct itertools::structs::Tuples">Tuples</a><I, T></span><code class="content"><span class="where fmt-newline">impl<I, T> Iterator for <a class="struct" href="structs/struct.Tuples.html" title="struct itertools::structs::Tuples">Tuples</a><I, T><span class="where fmt-newline">where<br> I: Iterator<Item = T::Item>,<br> T: <a class="trait" href="traits/trait.HomogeneousTuple.html" title="trait itertools::traits::HomogeneousTuple">HomogeneousTuple</a>,</span></span><span class="where fmt-newline"> type <a class="associatedtype">Item</a> = T;</span></code></span></span></span></span><br> <span class="where">where<br> Self: Sized + Iterator<Item = T::Item>,<br> T: <a class="trait" href="traits/trait.HomogeneousTuple.html" title="trait itertools::traits::HomogeneousTuple">HomogeneousTuple</a></span>, |
| { ... } |
| <span class="item-spacer"></span> fn <a href="#method.tee" class="fnname">tee</a>(self) -> (<a class="struct" href="structs/struct.Tee.html" title="struct itertools::structs::Tee">Tee</a><Self>, <a class="struct" href="structs/struct.Tee.html" title="struct itertools::structs::Tee">Tee</a><Self>)<br> <span class="where">where<br> Self: Sized,<br> Self::Item: Clone</span>, |
| { ... } |
| <span class="item-spacer"></span> fn <a href="#method.step" class="fnname">step</a>(self, n: usize) -> <a class="struct" href="structs/struct.Step.html" title="struct itertools::structs::Step">Step</a><Self><span class="notable-traits"><span class="notable-traits-tooltip">ⓘ<span class="notable-traits-tooltiptext"><span class="docblock"><span class="notable">Notable traits for <a class="struct" href="structs/struct.Step.html" title="struct itertools::structs::Step">Step</a><I></span><code class="content"><span class="where fmt-newline">impl<I> Iterator for <a class="struct" href="structs/struct.Step.html" title="struct itertools::structs::Step">Step</a><I><span class="where fmt-newline">where<br> I: Iterator,</span></span><span class="where fmt-newline"> type <a class="associatedtype">Item</a> = I::Item;</span></code></span></span></span></span><br> <span class="where">where<br> Self: Sized</span>, |
| { ... } |
| <span class="item-spacer"></span> fn <a href="#method.map_into" class="fnname">map_into</a><R>(self) -> <a class="type" href="structs/type.MapInto.html" title="type itertools::structs::MapInto">MapInto</a><Self, R><br> <span class="where">where<br> Self: Sized,<br> Self::Item: Into<R></span>, |
| { ... } |
| <span class="item-spacer"></span> fn <a href="#method.map_results" class="fnname">map_results</a><F, T, U, E>(self, f: F) -> <a class="type" href="structs/type.MapOk.html" title="type itertools::structs::MapOk">MapOk</a><Self, F><br> <span class="where">where<br> Self: Iterator<Item = Result<T, E>> + Sized,<br> F: FnMut(T) -> U</span>, |
| { ... } |
| <span class="item-spacer"></span> fn <a href="#method.map_ok" class="fnname">map_ok</a><F, T, U, E>(self, f: F) -> <a class="type" href="structs/type.MapOk.html" title="type itertools::structs::MapOk">MapOk</a><Self, F><br> <span class="where">where<br> Self: Iterator<Item = Result<T, E>> + Sized,<br> F: FnMut(T) -> U</span>, |
| { ... } |
| <span class="item-spacer"></span> fn <a href="#method.filter_ok" class="fnname">filter_ok</a><F, T, E>(self, f: F) -> <a class="struct" href="structs/struct.FilterOk.html" title="struct itertools::structs::FilterOk">FilterOk</a><Self, F><span class="notable-traits"><span class="notable-traits-tooltip">ⓘ<span class="notable-traits-tooltiptext"><span class="docblock"><span class="notable">Notable traits for <a class="struct" href="structs/struct.FilterOk.html" title="struct itertools::structs::FilterOk">FilterOk</a><I, F></span><code class="content"><span class="where fmt-newline">impl<I, F, T, E> Iterator for <a class="struct" href="structs/struct.FilterOk.html" title="struct itertools::structs::FilterOk">FilterOk</a><I, F><span class="where fmt-newline">where<br> I: Iterator<Item = Result<T, E>>,<br> F: FnMut(&T) -> bool,</span></span><span class="where fmt-newline"> type <a class="associatedtype">Item</a> = Result<T, E>;</span></code></span></span></span></span><br> <span class="where">where<br> Self: Iterator<Item = Result<T, E>> + Sized,<br> F: FnMut(&T) -> bool</span>, |
| { ... } |
| <span class="item-spacer"></span> fn <a href="#method.filter_map_ok" class="fnname">filter_map_ok</a><F, T, U, E>(self, f: F) -> <a class="struct" href="structs/struct.FilterMapOk.html" title="struct itertools::structs::FilterMapOk">FilterMapOk</a><Self, F><span class="notable-traits"><span class="notable-traits-tooltip">ⓘ<span class="notable-traits-tooltiptext"><span class="docblock"><span class="notable">Notable traits for <a class="struct" href="structs/struct.FilterMapOk.html" title="struct itertools::structs::FilterMapOk">FilterMapOk</a><I, F></span><code class="content"><span class="where fmt-newline">impl<I, F, T, U, E> Iterator for <a class="struct" href="structs/struct.FilterMapOk.html" title="struct itertools::structs::FilterMapOk">FilterMapOk</a><I, F><span class="where fmt-newline">where<br> I: Iterator<Item = Result<T, E>>,<br> F: FnMut(T) -> Option<U>,</span></span><span class="where fmt-newline"> type <a class="associatedtype">Item</a> = Result<U, E>;</span></code></span></span></span></span><br> <span class="where">where<br> Self: Iterator<Item = Result<T, E>> + Sized,<br> F: FnMut(T) -> Option<U></span>, |
| { ... } |
| <span class="item-spacer"></span> fn <a href="#method.flatten_ok" class="fnname">flatten_ok</a><T, E>(self) -> <a class="struct" href="structs/struct.FlattenOk.html" title="struct itertools::structs::FlattenOk">FlattenOk</a><Self, T, E><span class="notable-traits"><span class="notable-traits-tooltip">ⓘ<span class="notable-traits-tooltiptext"><span class="docblock"><span class="notable">Notable traits for <a class="struct" href="structs/struct.FlattenOk.html" title="struct itertools::structs::FlattenOk">FlattenOk</a><I, T, E></span><code class="content"><span class="where fmt-newline">impl<I, T, E> Iterator for <a class="struct" href="structs/struct.FlattenOk.html" title="struct itertools::structs::FlattenOk">FlattenOk</a><I, T, E><span class="where fmt-newline">where<br> I: Iterator<Item = Result<T, E>>,<br> T: IntoIterator,</span></span><span class="where fmt-newline"> type <a class="associatedtype">Item</a> = Result<T::Item, E>;</span></code></span></span></span></span><br> <span class="where">where<br> Self: Iterator<Item = Result<T, E>> + Sized,<br> T: IntoIterator</span>, |
| { ... } |
| <span class="item-spacer"></span> fn <a href="#method.merge" class="fnname">merge</a><J>(self, other: J) -> <a class="type" href="structs/type.Merge.html" title="type itertools::structs::Merge">Merge</a><Self, J::IntoIter><br> <span class="where">where<br> Self: Sized,<br> Self::Item: PartialOrd,<br> J: IntoIterator<Item = Self::Item></span>, |
| { ... } |
| <span class="item-spacer"></span> fn <a href="#method.merge_by" class="fnname">merge_by</a><J, F>(<br> self,<br> other: J,<br> is_first: F<br> ) -> <a class="struct" href="structs/struct.MergeBy.html" title="struct itertools::structs::MergeBy">MergeBy</a><Self, J::IntoIter, F><span class="notable-traits"><span class="notable-traits-tooltip">ⓘ<span class="notable-traits-tooltiptext"><span class="docblock"><span class="notable">Notable traits for <a class="struct" href="structs/struct.MergeBy.html" title="struct itertools::structs::MergeBy">MergeBy</a><I, J, F></span><code class="content"><span class="where fmt-newline">impl<I, J, F> Iterator for <a class="struct" href="structs/struct.MergeBy.html" title="struct itertools::structs::MergeBy">MergeBy</a><I, J, F><span class="where fmt-newline">where<br> I: Iterator,<br> J: Iterator<Item = I::Item>,<br> F: MergePredicate<I::Item>,</span></span><span class="where fmt-newline"> type <a class="associatedtype">Item</a> = I::Item;</span></code></span></span></span></span><br> <span class="where">where<br> Self: Sized,<br> J: IntoIterator<Item = Self::Item>,<br> F: FnMut(&Self::Item, &Self::Item) -> bool</span>, |
| { ... } |
| <span class="item-spacer"></span> fn <a href="#method.merge_join_by" class="fnname">merge_join_by</a><J, F>(<br> self,<br> other: J,<br> cmp_fn: F<br> ) -> <a class="struct" href="structs/struct.MergeJoinBy.html" title="struct itertools::structs::MergeJoinBy">MergeJoinBy</a><Self, J::IntoIter, F><span class="notable-traits"><span class="notable-traits-tooltip">ⓘ<span class="notable-traits-tooltiptext"><span class="docblock"><span class="notable">Notable traits for <a class="struct" href="structs/struct.MergeJoinBy.html" title="struct itertools::structs::MergeJoinBy">MergeJoinBy</a><I, J, F></span><code class="content"><span class="where fmt-newline">impl<I, J, F> Iterator for <a class="struct" href="structs/struct.MergeJoinBy.html" title="struct itertools::structs::MergeJoinBy">MergeJoinBy</a><I, J, F><span class="where fmt-newline">where<br> I: Iterator,<br> J: Iterator,<br> F: FnMut(&I::Item, &J::Item) -> Ordering,</span></span><span class="where fmt-newline"> type <a class="associatedtype">Item</a> = <a class="enum" href="enum.EitherOrBoth.html" title="enum itertools::EitherOrBoth">EitherOrBoth</a><I::Item, J::Item>;</span></code></span></span></span></span><br> <span class="where">where<br> J: IntoIterator,<br> F: FnMut(&Self::Item, &J::Item) -> Ordering,<br> Self: Sized</span>, |
| { ... } |
| <span class="item-spacer"></span> fn <a href="#method.kmerge" class="fnname">kmerge</a>(self) -> <a class="type" href="structs/type.KMerge.html" title="type itertools::structs::KMerge">KMerge</a><<Self::Item as IntoIterator>::IntoIter><br> <span class="where">where<br> Self: Sized,<br> Self::Item: IntoIterator,<br> <Self::Item as IntoIterator>::Item: PartialOrd</span>, |
| { ... } |
| <span class="item-spacer"></span> fn <a href="#method.kmerge_by" class="fnname">kmerge_by</a><F>(<br> self,<br> first: F<br> ) -> <a class="struct" href="structs/struct.KMergeBy.html" title="struct itertools::structs::KMergeBy">KMergeBy</a><<Self::Item as IntoIterator>::IntoIter, F><span class="notable-traits"><span class="notable-traits-tooltip">ⓘ<span class="notable-traits-tooltiptext"><span class="docblock"><span class="notable">Notable traits for <a class="struct" href="structs/struct.KMergeBy.html" title="struct itertools::structs::KMergeBy">KMergeBy</a><I, F></span><code class="content"><span class="where fmt-newline">impl<I, F> Iterator for <a class="struct" href="structs/struct.KMergeBy.html" title="struct itertools::structs::KMergeBy">KMergeBy</a><I, F><span class="where fmt-newline">where<br> I: Iterator,<br> F: KMergePredicate<I::Item>,</span></span><span class="where fmt-newline"> type <a class="associatedtype">Item</a> = I::Item;</span></code></span></span></span></span><br> <span class="where">where<br> Self: Sized,<br> Self::Item: IntoIterator,<br> F: FnMut(&<Self::Item as IntoIterator>::Item, &<Self::Item as IntoIterator>::Item) -> bool</span>, |
| { ... } |
| <span class="item-spacer"></span> fn <a href="#method.cartesian_product" class="fnname">cartesian_product</a><J>(self, other: J) -> <a class="struct" href="structs/struct.Product.html" title="struct itertools::structs::Product">Product</a><Self, J::IntoIter><span class="notable-traits"><span class="notable-traits-tooltip">ⓘ<span class="notable-traits-tooltiptext"><span class="docblock"><span class="notable">Notable traits for <a class="struct" href="structs/struct.Product.html" title="struct itertools::structs::Product">Product</a><I, J></span><code class="content"><span class="where fmt-newline">impl<I, J> Iterator for <a class="struct" href="structs/struct.Product.html" title="struct itertools::structs::Product">Product</a><I, J><span class="where fmt-newline">where<br> I: Iterator,<br> J: Clone + Iterator,<br> I::Item: Clone,</span></span><span class="where fmt-newline"> type <a class="associatedtype">Item</a> = (I::Item, J::Item);</span></code></span></span></span></span><br> <span class="where">where<br> Self: Sized,<br> Self::Item: Clone,<br> J: IntoIterator,<br> J::IntoIter: Clone</span>, |
| { ... } |
| <span class="item-spacer"></span> fn <a href="#method.multi_cartesian_product" class="fnname">multi_cartesian_product</a>(<br> self<br> ) -> <a class="struct" href="structs/struct.MultiProduct.html" title="struct itertools::structs::MultiProduct">MultiProduct</a><<Self::Item as IntoIterator>::IntoIter><span class="notable-traits"><span class="notable-traits-tooltip">ⓘ<span class="notable-traits-tooltiptext"><span class="docblock"><span class="notable">Notable traits for <a class="struct" href="structs/struct.MultiProduct.html" title="struct itertools::structs::MultiProduct">MultiProduct</a><I></span><code class="content"><span class="where fmt-newline">impl<I> Iterator for <a class="struct" href="structs/struct.MultiProduct.html" title="struct itertools::structs::MultiProduct">MultiProduct</a><I><span class="where fmt-newline">where<br> I: Iterator + Clone,<br> I::Item: Clone,</span></span><span class="where fmt-newline"> type <a class="associatedtype">Item</a> = Vec<I::Item>;</span></code></span></span></span></span><br> <span class="where">where<br> Self: Sized,<br> Self::Item: IntoIterator,<br> <Self::Item as IntoIterator>::IntoIter: Clone,<br> <Self::Item as IntoIterator>::Item: Clone</span>, |
| { ... } |
| <span class="item-spacer"></span> fn <a href="#method.coalesce" class="fnname">coalesce</a><F>(self, f: F) -> <a class="type" href="structs/type.Coalesce.html" title="type itertools::structs::Coalesce">Coalesce</a><Self, F><br> <span class="where">where<br> Self: Sized,<br> F: FnMut(Self::Item, Self::Item) -> Result<Self::Item, (Self::Item, Self::Item)></span>, |
| { ... } |
| <span class="item-spacer"></span> fn <a href="#method.dedup" class="fnname">dedup</a>(self) -> <a class="type" href="structs/type.Dedup.html" title="type itertools::structs::Dedup">Dedup</a><Self><br> <span class="where">where<br> Self: Sized,<br> Self::Item: PartialEq</span>, |
| { ... } |
| <span class="item-spacer"></span> fn <a href="#method.dedup_by" class="fnname">dedup_by</a><Cmp>(self, cmp: Cmp) -> <a class="type" href="structs/type.DedupBy.html" title="type itertools::structs::DedupBy">DedupBy</a><Self, Cmp><br> <span class="where">where<br> Self: Sized,<br> Cmp: FnMut(&Self::Item, &Self::Item) -> bool</span>, |
| { ... } |
| <span class="item-spacer"></span> fn <a href="#method.dedup_with_count" class="fnname">dedup_with_count</a>(self) -> <a class="type" href="structs/type.DedupWithCount.html" title="type itertools::structs::DedupWithCount">DedupWithCount</a><Self><br> <span class="where">where<br> Self: Sized</span>, |
| { ... } |
| <span class="item-spacer"></span> fn <a href="#method.dedup_by_with_count" class="fnname">dedup_by_with_count</a><Cmp>(self, cmp: Cmp) -> <a class="type" href="structs/type.DedupByWithCount.html" title="type itertools::structs::DedupByWithCount">DedupByWithCount</a><Self, Cmp><br> <span class="where">where<br> Self: Sized,<br> Cmp: FnMut(&Self::Item, &Self::Item) -> bool</span>, |
| { ... } |
| <span class="item-spacer"></span> fn <a href="#method.duplicates" class="fnname">duplicates</a>(self) -> <a class="type" href="structs/type.Duplicates.html" title="type itertools::structs::Duplicates">Duplicates</a><Self><br> <span class="where">where<br> Self: Sized,<br> Self::Item: Eq + Hash</span>, |
| { ... } |
| <span class="item-spacer"></span> fn <a href="#method.duplicates_by" class="fnname">duplicates_by</a><V, F>(self, f: F) -> <a class="type" href="structs/type.DuplicatesBy.html" title="type itertools::structs::DuplicatesBy">DuplicatesBy</a><Self, V, F><br> <span class="where">where<br> Self: Sized,<br> V: Eq + Hash,<br> F: FnMut(&Self::Item) -> V</span>, |
| { ... } |
| <span class="item-spacer"></span> fn <a href="#method.unique" class="fnname">unique</a>(self) -> <a class="struct" href="structs/struct.Unique.html" title="struct itertools::structs::Unique">Unique</a><Self><span class="notable-traits"><span class="notable-traits-tooltip">ⓘ<span class="notable-traits-tooltiptext"><span class="docblock"><span class="notable">Notable traits for <a class="struct" href="structs/struct.Unique.html" title="struct itertools::structs::Unique">Unique</a><I></span><code class="content"><span class="where fmt-newline">impl<I> Iterator for <a class="struct" href="structs/struct.Unique.html" title="struct itertools::structs::Unique">Unique</a><I><span class="where fmt-newline">where<br> I: Iterator,<br> I::Item: Eq + Hash + Clone,</span></span><span class="where fmt-newline"> type <a class="associatedtype">Item</a> = I::Item;</span></code></span></span></span></span><br> <span class="where">where<br> Self: Sized,<br> Self::Item: Clone + Eq + Hash</span>, |
| { ... } |
| <span class="item-spacer"></span> fn <a href="#method.unique_by" class="fnname">unique_by</a><V, F>(self, f: F) -> <a class="struct" href="structs/struct.UniqueBy.html" title="struct itertools::structs::UniqueBy">UniqueBy</a><Self, V, F><span class="notable-traits"><span class="notable-traits-tooltip">ⓘ<span class="notable-traits-tooltiptext"><span class="docblock"><span class="notable">Notable traits for <a class="struct" href="structs/struct.UniqueBy.html" title="struct itertools::structs::UniqueBy">UniqueBy</a><I, V, F></span><code class="content"><span class="where fmt-newline">impl<I, V, F> Iterator for <a class="struct" href="structs/struct.UniqueBy.html" title="struct itertools::structs::UniqueBy">UniqueBy</a><I, V, F><span class="where fmt-newline">where<br> I: Iterator,<br> V: Eq + Hash,<br> F: FnMut(&I::Item) -> V,</span></span><span class="where fmt-newline"> type <a class="associatedtype">Item</a> = I::Item;</span></code></span></span></span></span><br> <span class="where">where<br> Self: Sized,<br> V: Eq + Hash,<br> F: FnMut(&Self::Item) -> V</span>, |
| { ... } |
| <span class="item-spacer"></span> fn <a href="#method.peeking_take_while" class="fnname">peeking_take_while</a><F>(<br> &mut self,<br> accept: F<br> ) -> <a class="struct" href="structs/struct.PeekingTakeWhile.html" title="struct itertools::structs::PeekingTakeWhile">PeekingTakeWhile</a><'_, Self, F><span class="notable-traits"><span class="notable-traits-tooltip">ⓘ<span class="notable-traits-tooltiptext"><span class="docblock"><span class="notable">Notable traits for <a class="struct" href="structs/struct.PeekingTakeWhile.html" title="struct itertools::structs::PeekingTakeWhile">PeekingTakeWhile</a><'a, I, F></span><code class="content"><span class="where fmt-newline">impl<'a, I, F> Iterator for <a class="struct" href="structs/struct.PeekingTakeWhile.html" title="struct itertools::structs::PeekingTakeWhile">PeekingTakeWhile</a><'a, I, F><span class="where fmt-newline">where<br> I: <a class="trait" href="trait.PeekingNext.html" title="trait itertools::PeekingNext">PeekingNext</a>,<br> F: FnMut(&I::Item) -> bool,</span></span><span class="where fmt-newline"> type <a class="associatedtype">Item</a> = I::Item;</span></code></span></span></span></span><br> <span class="where">where<br> Self: Sized + <a class="trait" href="trait.PeekingNext.html" title="trait itertools::PeekingNext">PeekingNext</a>,<br> F: FnMut(&Self::Item) -> bool</span>, |
| { ... } |
| <span class="item-spacer"></span> fn <a href="#method.take_while_ref" class="fnname">take_while_ref</a><F>(&mut self, accept: F) -> <a class="struct" href="structs/struct.TakeWhileRef.html" title="struct itertools::structs::TakeWhileRef">TakeWhileRef</a><'_, Self, F><span class="notable-traits"><span class="notable-traits-tooltip">ⓘ<span class="notable-traits-tooltiptext"><span class="docblock"><span class="notable">Notable traits for <a class="struct" href="structs/struct.TakeWhileRef.html" title="struct itertools::structs::TakeWhileRef">TakeWhileRef</a><'a, I, F></span><code class="content"><span class="where fmt-newline">impl<'a, I, F> Iterator for <a class="struct" href="structs/struct.TakeWhileRef.html" title="struct itertools::structs::TakeWhileRef">TakeWhileRef</a><'a, I, F><span class="where fmt-newline">where<br> I: Iterator + Clone,<br> F: FnMut(&I::Item) -> bool,</span></span><span class="where fmt-newline"> type <a class="associatedtype">Item</a> = I::Item;</span></code></span></span></span></span><br> <span class="where">where<br> Self: Clone,<br> F: FnMut(&Self::Item) -> bool</span>, |
| { ... } |
| <span class="item-spacer"></span> fn <a href="#method.while_some" class="fnname">while_some</a><A>(self) -> <a class="struct" href="structs/struct.WhileSome.html" title="struct itertools::structs::WhileSome">WhileSome</a><Self><span class="notable-traits"><span class="notable-traits-tooltip">ⓘ<span class="notable-traits-tooltiptext"><span class="docblock"><span class="notable">Notable traits for <a class="struct" href="structs/struct.WhileSome.html" title="struct itertools::structs::WhileSome">WhileSome</a><I></span><code class="content"><span class="where fmt-newline">impl<I, A> Iterator for <a class="struct" href="structs/struct.WhileSome.html" title="struct itertools::structs::WhileSome">WhileSome</a><I><span class="where fmt-newline">where<br> I: Iterator<Item = Option<A>>,</span></span><span class="where fmt-newline"> type <a class="associatedtype">Item</a> = A;</span></code></span></span></span></span><br> <span class="where">where<br> Self: Sized + Iterator<Item = Option<A>></span>, |
| { ... } |
| <span class="item-spacer"></span> fn <a href="#method.tuple_combinations" class="fnname">tuple_combinations</a><T>(self) -> <a class="struct" href="structs/struct.TupleCombinations.html" title="struct itertools::structs::TupleCombinations">TupleCombinations</a><Self, T><span class="notable-traits"><span class="notable-traits-tooltip">ⓘ<span class="notable-traits-tooltiptext"><span class="docblock"><span class="notable">Notable traits for <a class="struct" href="structs/struct.TupleCombinations.html" title="struct itertools::structs::TupleCombinations">TupleCombinations</a><I, T></span><code class="content"><span class="where fmt-newline">impl<I, T> Iterator for <a class="struct" href="structs/struct.TupleCombinations.html" title="struct itertools::structs::TupleCombinations">TupleCombinations</a><I, T><span class="where fmt-newline">where<br> I: Iterator,<br> T: HasCombination<I>,</span></span><span class="where fmt-newline"> type <a class="associatedtype">Item</a> = T;</span></code></span></span></span></span><br> <span class="where">where<br> Self: Sized + Clone,<br> Self::Item: Clone,<br> T: HasCombination<Self></span>, |
| { ... } |
| <span class="item-spacer"></span> fn <a href="#method.combinations" class="fnname">combinations</a>(self, k: usize) -> <a class="struct" href="structs/struct.Combinations.html" title="struct itertools::structs::Combinations">Combinations</a><Self><span class="notable-traits"><span class="notable-traits-tooltip">ⓘ<span class="notable-traits-tooltiptext"><span class="docblock"><span class="notable">Notable traits for <a class="struct" href="structs/struct.Combinations.html" title="struct itertools::structs::Combinations">Combinations</a><I></span><code class="content"><span class="where fmt-newline">impl<I> Iterator for <a class="struct" href="structs/struct.Combinations.html" title="struct itertools::structs::Combinations">Combinations</a><I><span class="where fmt-newline">where<br> I: Iterator,<br> I::Item: Clone,</span></span><span class="where fmt-newline"> type <a class="associatedtype">Item</a> = Vec<I::Item>;</span></code></span></span></span></span><br> <span class="where">where<br> Self: Sized,<br> Self::Item: Clone</span>, |
| { ... } |
| <span class="item-spacer"></span> fn <a href="#method.combinations_with_replacement" class="fnname">combinations_with_replacement</a>(<br> self,<br> k: usize<br> ) -> <a class="struct" href="structs/struct.CombinationsWithReplacement.html" title="struct itertools::structs::CombinationsWithReplacement">CombinationsWithReplacement</a><Self><span class="notable-traits"><span class="notable-traits-tooltip">ⓘ<span class="notable-traits-tooltiptext"><span class="docblock"><span class="notable">Notable traits for <a class="struct" href="structs/struct.CombinationsWithReplacement.html" title="struct itertools::structs::CombinationsWithReplacement">CombinationsWithReplacement</a><I></span><code class="content"><span class="where fmt-newline">impl<I> Iterator for <a class="struct" href="structs/struct.CombinationsWithReplacement.html" title="struct itertools::structs::CombinationsWithReplacement">CombinationsWithReplacement</a><I><span class="where fmt-newline">where<br> I: Iterator,<br> I::Item: Clone,</span></span><span class="where fmt-newline"> type <a class="associatedtype">Item</a> = Vec<I::Item>;</span></code></span></span></span></span><br> <span class="where">where<br> Self: Sized,<br> Self::Item: Clone</span>, |
| { ... } |
| <span class="item-spacer"></span> fn <a href="#method.permutations" class="fnname">permutations</a>(self, k: usize) -> <a class="struct" href="structs/struct.Permutations.html" title="struct itertools::structs::Permutations">Permutations</a><Self><span class="notable-traits"><span class="notable-traits-tooltip">ⓘ<span class="notable-traits-tooltiptext"><span class="docblock"><span class="notable">Notable traits for <a class="struct" href="structs/struct.Permutations.html" title="struct itertools::structs::Permutations">Permutations</a><I></span><code class="content"><span class="where fmt-newline">impl<I> Iterator for <a class="struct" href="structs/struct.Permutations.html" title="struct itertools::structs::Permutations">Permutations</a><I><span class="where fmt-newline">where<br> I: Iterator,<br> I::Item: Clone,</span></span><span class="where fmt-newline"> type <a class="associatedtype">Item</a> = Vec<I::Item>;</span></code></span></span></span></span><br> <span class="where">where<br> Self: Sized,<br> Self::Item: Clone</span>, |
| { ... } |
| <span class="item-spacer"></span> fn <a href="#method.powerset" class="fnname">powerset</a>(self) -> <a class="struct" href="structs/struct.Powerset.html" title="struct itertools::structs::Powerset">Powerset</a><Self><span class="notable-traits"><span class="notable-traits-tooltip">ⓘ<span class="notable-traits-tooltiptext"><span class="docblock"><span class="notable">Notable traits for <a class="struct" href="structs/struct.Powerset.html" title="struct itertools::structs::Powerset">Powerset</a><I></span><code class="content"><span class="where fmt-newline">impl<I> Iterator for <a class="struct" href="structs/struct.Powerset.html" title="struct itertools::structs::Powerset">Powerset</a><I><span class="where fmt-newline">where<br> I: Iterator,<br> I::Item: Clone,</span></span><span class="where fmt-newline"> type <a class="associatedtype">Item</a> = Vec<I::Item>;</span></code></span></span></span></span><br> <span class="where">where<br> Self: Sized,<br> Self::Item: Clone</span>, |
| { ... } |
| <span class="item-spacer"></span> fn <a href="#method.pad_using" class="fnname">pad_using</a><F>(self, min: usize, f: F) -> <a class="struct" href="structs/struct.PadUsing.html" title="struct itertools::structs::PadUsing">PadUsing</a><Self, F><span class="notable-traits"><span class="notable-traits-tooltip">ⓘ<span class="notable-traits-tooltiptext"><span class="docblock"><span class="notable">Notable traits for <a class="struct" href="structs/struct.PadUsing.html" title="struct itertools::structs::PadUsing">PadUsing</a><I, F></span><code class="content"><span class="where fmt-newline">impl<I, F> Iterator for <a class="struct" href="structs/struct.PadUsing.html" title="struct itertools::structs::PadUsing">PadUsing</a><I, F><span class="where fmt-newline">where<br> I: Iterator,<br> F: FnMut(usize) -> I::Item,</span></span><span class="where fmt-newline"> type <a class="associatedtype">Item</a> = I::Item;</span></code></span></span></span></span><br> <span class="where">where<br> Self: Sized,<br> F: FnMut(usize) -> Self::Item</span>, |
| { ... } |
| <span class="item-spacer"></span> fn <a href="#method.with_position" class="fnname">with_position</a>(self) -> <a class="struct" href="structs/struct.WithPosition.html" title="struct itertools::structs::WithPosition">WithPosition</a><Self><span class="notable-traits"><span class="notable-traits-tooltip">ⓘ<span class="notable-traits-tooltiptext"><span class="docblock"><span class="notable">Notable traits for <a class="struct" href="structs/struct.WithPosition.html" title="struct itertools::structs::WithPosition">WithPosition</a><I></span><code class="content"><span class="where fmt-newline">impl<I: Iterator> Iterator for <a class="struct" href="structs/struct.WithPosition.html" title="struct itertools::structs::WithPosition">WithPosition</a><I></span><span class="where fmt-newline"> type <a class="associatedtype">Item</a> = <a class="enum" href="enum.Position.html" title="enum itertools::Position">Position</a><I::Item>;</span></code></span></span></span></span><br> <span class="where">where<br> Self: Sized</span>, |
| { ... } |
| <span class="item-spacer"></span> fn <a href="#method.positions" class="fnname">positions</a><P>(self, predicate: P) -> <a class="struct" href="structs/struct.Positions.html" title="struct itertools::structs::Positions">Positions</a><Self, P><span class="notable-traits"><span class="notable-traits-tooltip">ⓘ<span class="notable-traits-tooltiptext"><span class="docblock"><span class="notable">Notable traits for <a class="struct" href="structs/struct.Positions.html" title="struct itertools::structs::Positions">Positions</a><I, F></span><code class="content"><span class="where fmt-newline">impl<I, F> Iterator for <a class="struct" href="structs/struct.Positions.html" title="struct itertools::structs::Positions">Positions</a><I, F><span class="where fmt-newline">where<br> I: Iterator,<br> F: FnMut(I::Item) -> bool,</span></span><span class="where fmt-newline"> type <a class="associatedtype">Item</a> = usize;</span></code></span></span></span></span><br> <span class="where">where<br> Self: Sized,<br> P: FnMut(Self::Item) -> bool</span>, |
| { ... } |
| <span class="item-spacer"></span> fn <a href="#method.update" class="fnname">update</a><F>(self, updater: F) -> <a class="struct" href="structs/struct.Update.html" title="struct itertools::structs::Update">Update</a><Self, F><span class="notable-traits"><span class="notable-traits-tooltip">ⓘ<span class="notable-traits-tooltiptext"><span class="docblock"><span class="notable">Notable traits for <a class="struct" href="structs/struct.Update.html" title="struct itertools::structs::Update">Update</a><I, F></span><code class="content"><span class="where fmt-newline">impl<I, F> Iterator for <a class="struct" href="structs/struct.Update.html" title="struct itertools::structs::Update">Update</a><I, F><span class="where fmt-newline">where<br> I: Iterator,<br> F: FnMut(&mut I::Item),</span></span><span class="where fmt-newline"> type <a class="associatedtype">Item</a> = I::Item;</span></code></span></span></span></span><br> <span class="where">where<br> Self: Sized,<br> F: FnMut(&mut Self::Item)</span>, |
| { ... } |
| <span class="item-spacer"></span> fn <a href="#method.next_tuple" class="fnname">next_tuple</a><T>(&mut self) -> Option<T><br> <span class="where">where<br> Self: Sized + Iterator<Item = T::Item>,<br> T: <a class="trait" href="traits/trait.HomogeneousTuple.html" title="trait itertools::traits::HomogeneousTuple">HomogeneousTuple</a></span>, |
| { ... } |
| <span class="item-spacer"></span> fn <a href="#method.collect_tuple" class="fnname">collect_tuple</a><T>(self) -> Option<T><br> <span class="where">where<br> Self: Sized + Iterator<Item = T::Item>,<br> T: <a class="trait" href="traits/trait.HomogeneousTuple.html" title="trait itertools::traits::HomogeneousTuple">HomogeneousTuple</a></span>, |
| { ... } |
| <span class="item-spacer"></span> fn <a href="#method.find_position" class="fnname">find_position</a><P>(&mut self, pred: P) -> Option<(usize, Self::Item)><br> <span class="where">where<br> P: FnMut(&Self::Item) -> bool</span>, |
| { ... } |
| <span class="item-spacer"></span> fn <a href="#method.find_or_last" class="fnname">find_or_last</a><P>(self, predicate: P) -> Option<Self::Item><br> <span class="where">where<br> Self: Sized,<br> P: FnMut(&Self::Item) -> bool</span>, |
| { ... } |
| <span class="item-spacer"></span> fn <a href="#method.find_or_first" class="fnname">find_or_first</a><P>(self, predicate: P) -> Option<Self::Item><br> <span class="where">where<br> Self: Sized,<br> P: FnMut(&Self::Item) -> bool</span>, |
| { ... } |
| <span class="item-spacer"></span> fn <a href="#method.contains" class="fnname">contains</a><Q>(&mut self, query: &Q) -> bool<br> <span class="where">where<br> Self: Sized,<br> Self::Item: Borrow<Q>,<br> Q: PartialEq</span>, |
| { ... } |
| <span class="item-spacer"></span> fn <a href="#method.all_equal" class="fnname">all_equal</a>(&mut self) -> bool<br> <span class="where">where<br> Self: Sized,<br> Self::Item: PartialEq</span>, |
| { ... } |
| <span class="item-spacer"></span> fn <a href="#method.all_unique" class="fnname">all_unique</a>(&mut self) -> bool<br> <span class="where">where<br> Self: Sized,<br> Self::Item: Eq + Hash</span>, |
| { ... } |
| <span class="item-spacer"></span> fn <a href="#method.dropping" class="fnname">dropping</a>(self, n: usize) -> Self<br> <span class="where">where<br> Self: Sized</span>, |
| { ... } |
| <span class="item-spacer"></span> fn <a href="#method.dropping_back" class="fnname">dropping_back</a>(self, n: usize) -> Self<br> <span class="where">where<br> Self: Sized,<br> Self: DoubleEndedIterator</span>, |
| { ... } |
| <span class="item-spacer"></span> fn <a href="#method.foreach" class="fnname">foreach</a><F>(self, f: F)<br> <span class="where">where<br> F: FnMut(Self::Item),<br> Self: Sized</span>, |
| { ... } |
| <span class="item-spacer"></span> fn <a href="#method.concat" class="fnname">concat</a>(self) -> Self::Item<br> <span class="where">where<br> Self: Sized,<br> Self::Item: Extend<<<Self as Iterator>::Item as IntoIterator>::Item> + IntoIterator + Default</span>, |
| { ... } |
| <span class="item-spacer"></span> fn <a href="#method.collect_vec" class="fnname">collect_vec</a>(self) -> Vec<Self::Item><br> <span class="where">where<br> Self: Sized</span>, |
| { ... } |
| <span class="item-spacer"></span> fn <a href="#method.try_collect" class="fnname">try_collect</a><T, U, E>(self) -> Result<U, E><br> <span class="where">where<br> Self: Sized + Iterator<Item = Result<T, E>>,<br> Result<U, E>: FromIterator<Result<T, E>></span>, |
| { ... } |
| <span class="item-spacer"></span> fn <a href="#method.set_from" class="fnname">set_from</a><'a, A: 'a, J>(&mut self, from: J) -> usize<br> <span class="where">where<br> Self: Iterator<Item = &'a mut A>,<br> J: IntoIterator<Item = A></span>, |
| { ... } |
| <span class="item-spacer"></span> fn <a href="#method.join" class="fnname">join</a>(&mut self, sep: &str) -> String<br> <span class="where">where<br> Self::Item: Display</span>, |
| { ... } |
| <span class="item-spacer"></span> fn <a href="#method.format" class="fnname">format</a>(self, sep: &str) -> <a class="struct" href="structs/struct.Format.html" title="struct itertools::structs::Format">Format</a><'_, Self><br> <span class="where">where<br> Self: Sized</span>, |
| { ... } |
| <span class="item-spacer"></span> fn <a href="#method.format_with" class="fnname">format_with</a><F>(self, sep: &str, format: F) -> <a class="struct" href="structs/struct.FormatWith.html" title="struct itertools::structs::FormatWith">FormatWith</a><'_, Self, F><br> <span class="where">where<br> Self: Sized,<br> F: FnMut(Self::Item, &mut dyn FnMut(&dyn Display) -> Result) -> Result</span>, |
| { ... } |
| <span class="item-spacer"></span> fn <a href="#method.fold_results" class="fnname">fold_results</a><A, E, B, F>(&mut self, start: B, f: F) -> Result<B, E><br> <span class="where">where<br> Self: Iterator<Item = Result<A, E>>,<br> F: FnMut(B, A) -> B</span>, |
| { ... } |
| <span class="item-spacer"></span> fn <a href="#method.fold_ok" class="fnname">fold_ok</a><A, E, B, F>(&mut self, start: B, f: F) -> Result<B, E><br> <span class="where">where<br> Self: Iterator<Item = Result<A, E>>,<br> F: FnMut(B, A) -> B</span>, |
| { ... } |
| <span class="item-spacer"></span> fn <a href="#method.fold_options" class="fnname">fold_options</a><A, B, F>(&mut self, start: B, f: F) -> Option<B><br> <span class="where">where<br> Self: Iterator<Item = Option<A>>,<br> F: FnMut(B, A) -> B</span>, |
| { ... } |
| <span class="item-spacer"></span> fn <a href="#method.fold1" class="fnname">fold1</a><F>(self, f: F) -> Option<Self::Item><br> <span class="where">where<br> F: FnMut(Self::Item, Self::Item) -> Self::Item,<br> Self: Sized</span>, |
| { ... } |
| <span class="item-spacer"></span> fn <a href="#method.tree_fold1" class="fnname">tree_fold1</a><F>(self, f: F) -> Option<Self::Item><br> <span class="where">where<br> F: FnMut(Self::Item, Self::Item) -> Self::Item,<br> Self: Sized</span>, |
| { ... } |
| <span class="item-spacer"></span> fn <a href="#method.fold_while" class="fnname">fold_while</a><B, F>(&mut self, init: B, f: F) -> <a class="enum" href="enum.FoldWhile.html" title="enum itertools::FoldWhile">FoldWhile</a><B><br> <span class="where">where<br> Self: Sized,<br> F: FnMut(B, Self::Item) -> <a class="enum" href="enum.FoldWhile.html" title="enum itertools::FoldWhile">FoldWhile</a><B></span>, |
| { ... } |
| <span class="item-spacer"></span> fn <a href="#method.sum1" class="fnname">sum1</a><S>(self) -> Option<S><br> <span class="where">where<br> Self: Sized,<br> S: Sum<Self::Item></span>, |
| { ... } |
| <span class="item-spacer"></span> fn <a href="#method.product1" class="fnname">product1</a><P>(self) -> Option<P><br> <span class="where">where<br> Self: Sized,<br> P: Product<Self::Item></span>, |
| { ... } |
| <span class="item-spacer"></span> fn <a href="#method.sorted_unstable" class="fnname">sorted_unstable</a>(self) -> IntoIter<Self::Item><br> <span class="where">where<br> Self: Sized,<br> Self::Item: Ord</span>, |
| { ... } |
| <span class="item-spacer"></span> fn <a href="#method.sorted_unstable_by" class="fnname">sorted_unstable_by</a><F>(self, cmp: F) -> IntoIter<Self::Item><br> <span class="where">where<br> Self: Sized,<br> F: FnMut(&Self::Item, &Self::Item) -> Ordering</span>, |
| { ... } |
| <span class="item-spacer"></span> fn <a href="#method.sorted_unstable_by_key" class="fnname">sorted_unstable_by_key</a><K, F>(self, f: F) -> IntoIter<Self::Item><br> <span class="where">where<br> Self: Sized,<br> K: Ord,<br> F: FnMut(&Self::Item) -> K</span>, |
| { ... } |
| <span class="item-spacer"></span> fn <a href="#method.sorted" class="fnname">sorted</a>(self) -> IntoIter<Self::Item><br> <span class="where">where<br> Self: Sized,<br> Self::Item: Ord</span>, |
| { ... } |
| <span class="item-spacer"></span> fn <a href="#method.sorted_by" class="fnname">sorted_by</a><F>(self, cmp: F) -> IntoIter<Self::Item><br> <span class="where">where<br> Self: Sized,<br> F: FnMut(&Self::Item, &Self::Item) -> Ordering</span>, |
| { ... } |
| <span class="item-spacer"></span> fn <a href="#method.sorted_by_key" class="fnname">sorted_by_key</a><K, F>(self, f: F) -> IntoIter<Self::Item><br> <span class="where">where<br> Self: Sized,<br> K: Ord,<br> F: FnMut(&Self::Item) -> K</span>, |
| { ... } |
| <span class="item-spacer"></span> fn <a href="#method.sorted_by_cached_key" class="fnname">sorted_by_cached_key</a><K, F>(self, f: F) -> IntoIter<Self::Item><br> <span class="where">where<br> Self: Sized,<br> K: Ord,<br> F: FnMut(&Self::Item) -> K</span>, |
| { ... } |
| <span class="item-spacer"></span> fn <a href="#method.k_smallest" class="fnname">k_smallest</a>(self, k: usize) -> IntoIter<Self::Item><br> <span class="where">where<br> Self: Sized,<br> Self::Item: Ord</span>, |
| { ... } |
| <span class="item-spacer"></span> fn <a href="#method.partition_map" class="fnname">partition_map</a><A, B, F, L, R>(self, predicate: F) -> (A, B)<br> <span class="where">where<br> Self: Sized,<br> F: FnMut(Self::Item) -> <a class="enum" href="enum.Either.html" title="enum itertools::Either">Either</a><L, R>,<br> A: Default + Extend<L>,<br> B: Default + Extend<R></span>, |
| { ... } |
| <span class="item-spacer"></span> fn <a href="#method.partition_result" class="fnname">partition_result</a><A, B, T, E>(self) -> (A, B)<br> <span class="where">where<br> Self: Iterator<Item = Result<T, E>> + Sized,<br> A: Default + Extend<T>,<br> B: Default + Extend<E></span>, |
| { ... } |
| <span class="item-spacer"></span> fn <a href="#method.into_group_map" class="fnname">into_group_map</a><K, V>(self) -> HashMap<K, Vec<V>><br> <span class="where">where<br> Self: Iterator<Item = (K, V)> + Sized,<br> K: Hash + Eq</span>, |
| { ... } |
| <span class="item-spacer"></span> fn <a href="#method.into_group_map_by" class="fnname">into_group_map_by</a><K, V, F>(self, f: F) -> HashMap<K, Vec<V>><br> <span class="where">where<br> Self: Iterator<Item = V> + Sized,<br> K: Hash + Eq,<br> F: Fn(&V) -> K</span>, |
| { ... } |
| <span class="item-spacer"></span> fn <a href="#method.into_grouping_map" class="fnname">into_grouping_map</a><K, V>(self) -> <a class="struct" href="structs/struct.GroupingMap.html" title="struct itertools::structs::GroupingMap">GroupingMap</a><Self><br> <span class="where">where<br> Self: Iterator<Item = (K, V)> + Sized,<br> K: Hash + Eq</span>, |
| { ... } |
| <span class="item-spacer"></span> fn <a href="#method.into_grouping_map_by" class="fnname">into_grouping_map_by</a><K, V, F>(<br> self,<br> key_mapper: F<br> ) -> <a class="type" href="structs/type.GroupingMapBy.html" title="type itertools::structs::GroupingMapBy">GroupingMapBy</a><Self, F><br> <span class="where">where<br> Self: Iterator<Item = V> + Sized,<br> K: Hash + Eq,<br> F: FnMut(&V) -> K</span>, |
| { ... } |
| <span class="item-spacer"></span> fn <a href="#method.min_set" class="fnname">min_set</a>(self) -> Vec<Self::Item><br> <span class="where">where<br> Self: Sized,<br> Self::Item: Ord</span>, |
| { ... } |
| <span class="item-spacer"></span> fn <a href="#method.min_set_by" class="fnname">min_set_by</a><F>(self, compare: F) -> Vec<Self::Item><br> <span class="where">where<br> Self: Sized,<br> F: FnMut(&Self::Item, &Self::Item) -> Ordering</span>, |
| { ... } |
| <span class="item-spacer"></span> fn <a href="#method.min_set_by_key" class="fnname">min_set_by_key</a><K, F>(self, key: F) -> Vec<Self::Item><br> <span class="where">where<br> Self: Sized,<br> K: Ord,<br> F: FnMut(&Self::Item) -> K</span>, |
| { ... } |
| <span class="item-spacer"></span> fn <a href="#method.max_set" class="fnname">max_set</a>(self) -> Vec<Self::Item><br> <span class="where">where<br> Self: Sized,<br> Self::Item: Ord</span>, |
| { ... } |
| <span class="item-spacer"></span> fn <a href="#method.max_set_by" class="fnname">max_set_by</a><F>(self, compare: F) -> Vec<Self::Item><br> <span class="where">where<br> Self: Sized,<br> F: FnMut(&Self::Item, &Self::Item) -> Ordering</span>, |
| { ... } |
| <span class="item-spacer"></span> fn <a href="#method.max_set_by_key" class="fnname">max_set_by_key</a><K, F>(self, key: F) -> Vec<Self::Item><br> <span class="where">where<br> Self: Sized,<br> K: Ord,<br> F: FnMut(&Self::Item) -> K</span>, |
| { ... } |
| <span class="item-spacer"></span> fn <a href="#method.minmax" class="fnname">minmax</a>(self) -> <a class="enum" href="enum.MinMaxResult.html" title="enum itertools::MinMaxResult">MinMaxResult</a><Self::Item><br> <span class="where">where<br> Self: Sized,<br> Self::Item: PartialOrd</span>, |
| { ... } |
| <span class="item-spacer"></span> fn <a href="#method.minmax_by_key" class="fnname">minmax_by_key</a><K, F>(self, key: F) -> <a class="enum" href="enum.MinMaxResult.html" title="enum itertools::MinMaxResult">MinMaxResult</a><Self::Item><br> <span class="where">where<br> Self: Sized,<br> K: PartialOrd,<br> F: FnMut(&Self::Item) -> K</span>, |
| { ... } |
| <span class="item-spacer"></span> fn <a href="#method.minmax_by" class="fnname">minmax_by</a><F>(self, compare: F) -> <a class="enum" href="enum.MinMaxResult.html" title="enum itertools::MinMaxResult">MinMaxResult</a><Self::Item><br> <span class="where">where<br> Self: Sized,<br> F: FnMut(&Self::Item, &Self::Item) -> Ordering</span>, |
| { ... } |
| <span class="item-spacer"></span> fn <a href="#method.position_max" class="fnname">position_max</a>(self) -> Option<usize><br> <span class="where">where<br> Self: Sized,<br> Self::Item: Ord</span>, |
| { ... } |
| <span class="item-spacer"></span> fn <a href="#method.position_max_by_key" class="fnname">position_max_by_key</a><K, F>(self, key: F) -> Option<usize><br> <span class="where">where<br> Self: Sized,<br> K: Ord,<br> F: FnMut(&Self::Item) -> K</span>, |
| { ... } |
| <span class="item-spacer"></span> fn <a href="#method.position_max_by" class="fnname">position_max_by</a><F>(self, compare: F) -> Option<usize><br> <span class="where">where<br> Self: Sized,<br> F: FnMut(&Self::Item, &Self::Item) -> Ordering</span>, |
| { ... } |
| <span class="item-spacer"></span> fn <a href="#method.position_min" class="fnname">position_min</a>(self) -> Option<usize><br> <span class="where">where<br> Self: Sized,<br> Self::Item: Ord</span>, |
| { ... } |
| <span class="item-spacer"></span> fn <a href="#method.position_min_by_key" class="fnname">position_min_by_key</a><K, F>(self, key: F) -> Option<usize><br> <span class="where">where<br> Self: Sized,<br> K: Ord,<br> F: FnMut(&Self::Item) -> K</span>, |
| { ... } |
| <span class="item-spacer"></span> fn <a href="#method.position_min_by" class="fnname">position_min_by</a><F>(self, compare: F) -> Option<usize><br> <span class="where">where<br> Self: Sized,<br> F: FnMut(&Self::Item, &Self::Item) -> Ordering</span>, |
| { ... } |
| <span class="item-spacer"></span> fn <a href="#method.position_minmax" class="fnname">position_minmax</a>(self) -> <a class="enum" href="enum.MinMaxResult.html" title="enum itertools::MinMaxResult">MinMaxResult</a><usize><br> <span class="where">where<br> Self: Sized,<br> Self::Item: PartialOrd</span>, |
| { ... } |
| <span class="item-spacer"></span> fn <a href="#method.position_minmax_by_key" class="fnname">position_minmax_by_key</a><K, F>(self, key: F) -> <a class="enum" href="enum.MinMaxResult.html" title="enum itertools::MinMaxResult">MinMaxResult</a><usize><br> <span class="where">where<br> Self: Sized,<br> K: PartialOrd,<br> F: FnMut(&Self::Item) -> K</span>, |
| { ... } |
| <span class="item-spacer"></span> fn <a href="#method.position_minmax_by" class="fnname">position_minmax_by</a><F>(self, compare: F) -> <a class="enum" href="enum.MinMaxResult.html" title="enum itertools::MinMaxResult">MinMaxResult</a><usize><br> <span class="where">where<br> Self: Sized,<br> F: FnMut(&Self::Item, &Self::Item) -> Ordering</span>, |
| { ... } |
| <span class="item-spacer"></span> fn <a href="#method.exactly_one" class="fnname">exactly_one</a>(self) -> Result<Self::Item, <a class="struct" href="structs/struct.ExactlyOneError.html" title="struct itertools::structs::ExactlyOneError">ExactlyOneError</a><Self>><br> <span class="where">where<br> Self: Sized</span>, |
| { ... } |
| <span class="item-spacer"></span> fn <a href="#method.at_most_one" class="fnname">at_most_one</a>(self) -> Result<Option<Self::Item>, <a class="struct" href="structs/struct.ExactlyOneError.html" title="struct itertools::structs::ExactlyOneError">ExactlyOneError</a><Self>><br> <span class="where">where<br> Self: Sized</span>, |
| { ... } |
| <span class="item-spacer"></span> fn <a href="#method.multipeek" class="fnname">multipeek</a>(self) -> <a class="struct" href="structs/struct.MultiPeek.html" title="struct itertools::structs::MultiPeek">MultiPeek</a><Self><span class="notable-traits"><span class="notable-traits-tooltip">ⓘ<span class="notable-traits-tooltiptext"><span class="docblock"><span class="notable">Notable traits for <a class="struct" href="structs/struct.MultiPeek.html" title="struct itertools::structs::MultiPeek">MultiPeek</a><I></span><code class="content"><span class="where fmt-newline">impl<I> Iterator for <a class="struct" href="structs/struct.MultiPeek.html" title="struct itertools::structs::MultiPeek">MultiPeek</a><I><span class="where fmt-newline">where<br> I: Iterator,</span></span><span class="where fmt-newline"> type <a class="associatedtype">Item</a> = I::Item;</span></code></span></span></span></span><br> <span class="where">where<br> Self: Sized</span>, |
| { ... } |
| <span class="item-spacer"></span> fn <a href="#method.counts" class="fnname">counts</a>(self) -> HashMap<Self::Item, usize><br> <span class="where">where<br> Self: Sized,<br> Self::Item: Eq + Hash</span>, |
| { ... } |
| <span class="item-spacer"></span> fn <a href="#method.counts_by" class="fnname">counts_by</a><K, F>(self, f: F) -> HashMap<K, usize><br> <span class="where">where<br> Self: Sized,<br> K: Eq + Hash,<br> F: FnMut(Self::Item) -> K</span>, |
| { ... } |
| <span class="item-spacer"></span> fn <a href="#method.multiunzip" class="fnname">multiunzip</a><FromI>(self) -> FromI<br> <span class="where">where<br> Self: Sized + <a class="trait" href="trait.MultiUnzip.html" title="trait itertools::MultiUnzip">MultiUnzip</a><FromI></span>, |
| { ... } |
| </details>}</code></pre></div><details class="rustdoc-toggle top-doc" open><summary class="hideme"><span>Expand description</span></summary><div class="docblock"><p>An [<code>Iterator</code>] blanket implementation that provides extra adaptors and |
| methods.</p> |
| <p>This trait defines a number of methods. They are divided into two groups:</p> |
| <ul> |
| <li> |
| <p><em>Adaptors</em> 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 <a href="trait.Itertools.html#method.interleave"><code>.interleave()</code></a></p> |
| </li> |
| <li> |
| <p><em>Regular methods</em> are those that don’t return iterators and instead |
| return a regular value of some other kind. |
| <a href="trait.Itertools.html#method.next_tuple"><code>.next_tuple()</code></a> is an example and the first regular |
| method in the list.</p> |
| </li> |
| </ul> |
| </div></details><h2 id="provided-methods" class="small-section-header">Provided Methods<a href="#provided-methods" class="anchor"></a></h2><div class="methods"><details class="rustdoc-toggle method-toggle" open><summary><section id="method.interleave" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#446-451">source</a><h4 class="code-header">fn <a href="#method.interleave" class="fnname">interleave</a><J>(self, other: J) -> <a class="struct" href="structs/struct.Interleave.html" title="struct itertools::structs::Interleave">Interleave</a><Self, J::IntoIter><span class="notable-traits"><span class="notable-traits-tooltip">ⓘ<span class="notable-traits-tooltiptext"><span class="docblock"><span class="notable">Notable traits for <a class="struct" href="structs/struct.Interleave.html" title="struct itertools::structs::Interleave">Interleave</a><I, J></span><code class="content"><span class="where fmt-newline">impl<I, J> Iterator for <a class="struct" href="structs/struct.Interleave.html" title="struct itertools::structs::Interleave">Interleave</a><I, J><span class="where fmt-newline">where<br> I: Iterator,<br> J: Iterator<Item = I::Item>,</span></span><span class="where fmt-newline"> type <a class="associatedtype">Item</a> = I::Item;</span></code></span></span></span></span><span class="where fmt-newline">where<br> J: IntoIterator<Item = Self::Item>,<br> Self: Sized,</span></h4></section></summary><div class="docblock"><p>Alternate elements from two iterators until both have run out.</p> |
| <p>Iterator element type is <code>Self::Item</code>.</p> |
| <p>This iterator is <em>fused</em>.</p> |
| |
| <div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>itertools::Itertools; |
| |
| <span class="kw">let </span>it = (<span class="number">1</span>..<span class="number">7</span>).interleave(<span class="macro">vec!</span>[-<span class="number">1</span>, -<span class="number">2</span>]); |
| itertools::assert_equal(it, <span class="macro">vec!</span>[<span class="number">1</span>, -<span class="number">1</span>, <span class="number">2</span>, -<span class="number">2</span>, <span class="number">3</span>, <span class="number">4</span>, <span class="number">5</span>, <span class="number">6</span>]);</code></pre></div> |
| </div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.interleave_shortest" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#464-469">source</a><h4 class="code-header">fn <a href="#method.interleave_shortest" class="fnname">interleave_shortest</a><J>(<br> self,<br> other: J<br>) -> <a class="struct" href="structs/struct.InterleaveShortest.html" title="struct itertools::structs::InterleaveShortest">InterleaveShortest</a><Self, J::IntoIter><span class="notable-traits"><span class="notable-traits-tooltip">ⓘ<span class="notable-traits-tooltiptext"><span class="docblock"><span class="notable">Notable traits for <a class="struct" href="structs/struct.InterleaveShortest.html" title="struct itertools::structs::InterleaveShortest">InterleaveShortest</a><I, J></span><code class="content"><span class="where fmt-newline">impl<I, J> Iterator for <a class="struct" href="structs/struct.InterleaveShortest.html" title="struct itertools::structs::InterleaveShortest">InterleaveShortest</a><I, J><span class="where fmt-newline">where<br> I: Iterator,<br> J: Iterator<Item = I::Item>,</span></span><span class="where fmt-newline"> type <a class="associatedtype">Item</a> = I::Item;</span></code></span></span></span></span><span class="where fmt-newline">where<br> J: IntoIterator<Item = Self::Item>,<br> Self: Sized,</span></h4></section></summary><div class="docblock"><p>Alternate elements from two iterators until at least one of them has run |
| out.</p> |
| <p>Iterator element type is <code>Self::Item</code>.</p> |
| |
| <div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>itertools::Itertools; |
| |
| <span class="kw">let </span>it = (<span class="number">1</span>..<span class="number">7</span>).interleave_shortest(<span class="macro">vec!</span>[-<span class="number">1</span>, -<span class="number">2</span>]); |
| itertools::assert_equal(it, <span class="macro">vec!</span>[<span class="number">1</span>, -<span class="number">1</span>, <span class="number">2</span>, -<span class="number">2</span>, <span class="number">3</span>]);</code></pre></div> |
| </div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.intersperse" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#483-488">source</a><h4 class="code-header">fn <a href="#method.intersperse" class="fnname">intersperse</a>(self, element: Self::Item) -> <a class="type" href="structs/type.Intersperse.html" title="type itertools::structs::Intersperse">Intersperse</a><Self><span class="where fmt-newline">where<br> Self: Sized,<br> Self::Item: Clone,</span></h4></section></summary><div class="docblock"><p>An iterator adaptor to insert a particular value |
| between each element of the adapted iterator.</p> |
| <p>Iterator element type is <code>Self::Item</code>.</p> |
| <p>This iterator is <em>fused</em>.</p> |
| |
| <div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>itertools::Itertools; |
| |
| itertools::assert_equal((<span class="number">0</span>..<span class="number">3</span>).intersperse(<span class="number">8</span>), <span class="macro">vec!</span>[<span class="number">0</span>, <span class="number">8</span>, <span class="number">1</span>, <span class="number">8</span>, <span class="number">2</span>]);</code></pre></div> |
| </div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.intersperse_with" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#504-509">source</a><h4 class="code-header">fn <a href="#method.intersperse_with" class="fnname">intersperse_with</a><F>(self, element: F) -> <a class="struct" href="structs/struct.IntersperseWith.html" title="struct itertools::structs::IntersperseWith">IntersperseWith</a><Self, F><span class="notable-traits"><span class="notable-traits-tooltip">ⓘ<span class="notable-traits-tooltiptext"><span class="docblock"><span class="notable">Notable traits for <a class="struct" href="structs/struct.IntersperseWith.html" title="struct itertools::structs::IntersperseWith">IntersperseWith</a><I, ElemF></span><code class="content"><span class="where fmt-newline">impl<I, ElemF> Iterator for <a class="struct" href="structs/struct.IntersperseWith.html" title="struct itertools::structs::IntersperseWith">IntersperseWith</a><I, ElemF><span class="where fmt-newline">where<br> I: Iterator,<br> ElemF: IntersperseElement<I::Item>,</span></span><span class="where fmt-newline"> type <a class="associatedtype">Item</a> = I::Item;</span></code></span></span></span></span><span class="where fmt-newline">where<br> Self: Sized,<br> F: FnMut() -> Self::Item,</span></h4></section></summary><div class="docblock"><p>An iterator adaptor to insert a particular value created by a function |
| between each element of the adapted iterator.</p> |
| <p>Iterator element type is <code>Self::Item</code>.</p> |
| <p>This iterator is <em>fused</em>.</p> |
| |
| <div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>itertools::Itertools; |
| |
| <span class="kw">let </span><span class="kw-2">mut </span>i = <span class="number">10</span>; |
| itertools::assert_equal((<span class="number">0</span>..<span class="number">3</span>).intersperse_with(|| { i -= <span class="number">1</span>; i }), <span class="macro">vec!</span>[<span class="number">0</span>, <span class="number">9</span>, <span class="number">1</span>, <span class="number">8</span>, <span class="number">2</span>]); |
| <span class="macro">assert_eq!</span>(i, <span class="number">8</span>);</code></pre></div> |
| </div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.zip_longest" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#538-543">source</a><h4 class="code-header">fn <a href="#method.zip_longest" class="fnname">zip_longest</a><J>(self, other: J) -> <a class="struct" href="structs/struct.ZipLongest.html" title="struct itertools::structs::ZipLongest">ZipLongest</a><Self, J::IntoIter><span class="notable-traits"><span class="notable-traits-tooltip">ⓘ<span class="notable-traits-tooltiptext"><span class="docblock"><span class="notable">Notable traits for <a class="struct" href="structs/struct.ZipLongest.html" title="struct itertools::structs::ZipLongest">ZipLongest</a><T, U></span><code class="content"><span class="where fmt-newline">impl<T, U> Iterator for <a class="struct" href="structs/struct.ZipLongest.html" title="struct itertools::structs::ZipLongest">ZipLongest</a><T, U><span class="where fmt-newline">where<br> T: Iterator,<br> U: Iterator,</span></span><span class="where fmt-newline"> type <a class="associatedtype">Item</a> = <a class="enum" href="enum.EitherOrBoth.html" title="enum itertools::EitherOrBoth">EitherOrBoth</a><T::Item, U::Item>;</span></code></span></span></span></span><span class="where fmt-newline">where<br> J: IntoIterator,<br> Self: Sized,</span></h4></section></summary><div class="docblock"><p>Create an iterator which iterates over both this and the specified |
| iterator simultaneously, yielding pairs of two optional elements.</p> |
| <p>This iterator is <em>fused</em>.</p> |
| <p>As long as neither input iterator is exhausted yet, it yields two values |
| via <code>EitherOrBoth::Both</code>.</p> |
| <p>When the parameter iterator is exhausted, it only yields a value from the |
| <code>self</code> iterator via <code>EitherOrBoth::Left</code>.</p> |
| <p>When the <code>self</code> iterator is exhausted, it only yields a value from the |
| parameter iterator via <code>EitherOrBoth::Right</code>.</p> |
| <p>When both iterators return <code>None</code>, all further invocations of <code>.next()</code> |
| will return <code>None</code>.</p> |
| <p>Iterator element type is |
| <a href="enum.EitherOrBoth.html"><code>EitherOrBoth<Self::Item, J::Item></code></a>.</p> |
| |
| <div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>itertools::EitherOrBoth::{Both, Right}; |
| <span class="kw">use </span>itertools::Itertools; |
| <span class="kw">let </span>it = (<span class="number">0</span>..<span class="number">1</span>).zip_longest(<span class="number">1</span>..<span class="number">3</span>); |
| itertools::assert_equal(it, <span class="macro">vec!</span>[Both(<span class="number">0</span>, <span class="number">1</span>), Right(<span class="number">2</span>)]);</code></pre></div> |
| </div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.zip_eq" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#551-556">source</a><h4 class="code-header">fn <a href="#method.zip_eq" class="fnname">zip_eq</a><J>(self, other: J) -> <a class="struct" href="structs/struct.ZipEq.html" title="struct itertools::structs::ZipEq">ZipEq</a><Self, J::IntoIter><span class="notable-traits"><span class="notable-traits-tooltip">ⓘ<span class="notable-traits-tooltiptext"><span class="docblock"><span class="notable">Notable traits for <a class="struct" href="structs/struct.ZipEq.html" title="struct itertools::structs::ZipEq">ZipEq</a><I, J></span><code class="content"><span class="where fmt-newline">impl<I, J> Iterator for <a class="struct" href="structs/struct.ZipEq.html" title="struct itertools::structs::ZipEq">ZipEq</a><I, J><span class="where fmt-newline">where<br> I: Iterator,<br> J: Iterator,</span></span><span class="where fmt-newline"> type <a class="associatedtype">Item</a> = (I::Item, J::Item);</span></code></span></span></span></span><span class="where fmt-newline">where<br> J: IntoIterator,<br> Self: Sized,</span></h4></section></summary><div class="docblock"><p>Create an iterator which iterates over both this and the specified |
| iterator simultaneously, yielding pairs of elements.</p> |
| <p><strong>Panics</strong> if the iterators reach an end and they are not of equal |
| lengths.</p> |
| </div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.batching" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#581-586">source</a><h4 class="code-header">fn <a href="#method.batching" class="fnname">batching</a><B, F>(self, f: F) -> <a class="struct" href="structs/struct.Batching.html" title="struct itertools::structs::Batching">Batching</a><Self, F><span class="notable-traits"><span class="notable-traits-tooltip">ⓘ<span class="notable-traits-tooltiptext"><span class="docblock"><span class="notable">Notable traits for <a class="struct" href="structs/struct.Batching.html" title="struct itertools::structs::Batching">Batching</a><I, F></span><code class="content"><span class="where fmt-newline">impl<B, F, I> Iterator for <a class="struct" href="structs/struct.Batching.html" title="struct itertools::structs::Batching">Batching</a><I, F><span class="where fmt-newline">where<br> I: Iterator,<br> F: FnMut(&mut I) -> Option<B>,</span></span><span class="where fmt-newline"> type <a class="associatedtype">Item</a> = B;</span></code></span></span></span></span><span class="where fmt-newline">where<br> F: FnMut(&mut Self) -> Option<B>,<br> Self: Sized,</span></h4></section></summary><div class="docblock"><p>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.</p> |
| <p>Iterator element type is <code>B</code>.</p> |
| |
| <div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>itertools::Itertools; |
| |
| <span class="comment">// An adaptor that gathers elements in pairs |
| </span><span class="kw">let </span>pit = (<span class="number">0</span>..<span class="number">4</span>).batching(|it| { |
| <span class="kw">match </span>it.next() { |
| <span class="prelude-val">None </span>=> <span class="prelude-val">None</span>, |
| <span class="prelude-val">Some</span>(x) => <span class="kw">match </span>it.next() { |
| <span class="prelude-val">None </span>=> <span class="prelude-val">None</span>, |
| <span class="prelude-val">Some</span>(y) => <span class="prelude-val">Some</span>((x, y)), |
| } |
| } |
| }); |
| |
| itertools::assert_equal(pit, <span class="macro">vec!</span>[(<span class="number">0</span>, <span class="number">1</span>), (<span class="number">2</span>, <span class="number">3</span>)]);</code></pre></div> |
| </div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.group_by" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#623-629">source</a><h4 class="code-header">fn <a href="#method.group_by" class="fnname">group_by</a><K, F>(self, key: F) -> <a class="struct" href="structs/struct.GroupBy.html" title="struct itertools::structs::GroupBy">GroupBy</a><K, Self, F><span class="where fmt-newline">where<br> Self: Sized,<br> F: FnMut(&Self::Item) -> K,<br> K: PartialEq,</span></h4></section></summary><div class="docblock"><p>Return an <em>iterable</em> that can group iterator elements. |
| Consecutive elements that map to the same key (“runs”), are assigned |
| to the same group.</p> |
| <p><code>GroupBy</code> is the storage for the lazy grouping operation.</p> |
| <p>If the groups are consumed in order, or if each group’s iterator is |
| dropped without keeping it around, then <code>GroupBy</code> uses no |
| allocations. It needs allocations only if several group iterators |
| are alive at the same time.</p> |
| <p>This type implements [<code>IntoIterator</code>] (it is <strong>not</strong> 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.</p> |
| <p>Iterator element type is <code>(K, Group)</code>: the group’s key and the |
| group iterator.</p> |
| |
| <div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>itertools::Itertools; |
| |
| <span class="comment">// group data into runs of larger than zero or not. |
| </span><span class="kw">let </span>data = <span class="macro">vec!</span>[<span class="number">1</span>, <span class="number">3</span>, -<span class="number">2</span>, -<span class="number">2</span>, <span class="number">1</span>, <span class="number">0</span>, <span class="number">1</span>, <span class="number">2</span>]; |
| <span class="comment">// groups: |---->|------>|--------->| |
| |
| // Note: The `&` is significant here, `GroupBy` is iterable |
| // only by reference. You can also call `.into_iter()` explicitly. |
| </span><span class="kw">let </span><span class="kw-2">mut </span>data_grouped = Vec::new(); |
| <span class="kw">for </span>(key, group) <span class="kw">in </span><span class="kw-2">&</span>data.into_iter().group_by(|elt| <span class="kw-2">*</span>elt >= <span class="number">0</span>) { |
| data_grouped.push((key, group.collect())); |
| } |
| <span class="macro">assert_eq!</span>(data_grouped, <span class="macro">vec!</span>[(<span class="bool-val">true</span>, <span class="macro">vec!</span>[<span class="number">1</span>, <span class="number">3</span>]), (<span class="bool-val">false</span>, <span class="macro">vec!</span>[-<span class="number">2</span>, -<span class="number">2</span>]), (<span class="bool-val">true</span>, <span class="macro">vec!</span>[<span class="number">1</span>, <span class="number">0</span>, <span class="number">1</span>, <span class="number">2</span>])]);</code></pre></div> |
| </div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.chunks" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#659-664">source</a><h4 class="code-header">fn <a href="#method.chunks" class="fnname">chunks</a>(self, size: usize) -> <a class="struct" href="structs/struct.IntoChunks.html" title="struct itertools::structs::IntoChunks">IntoChunks</a><Self><span class="where fmt-newline">where<br> Self: Sized,</span></h4></section></summary><div class="docblock"><p>Return an <em>iterable</em> that can chunk the iterator.</p> |
| <p>Yield subiterators (chunks) that each yield a fixed number elements, |
| determined by <code>size</code>. The last chunk will be shorter if there aren’t |
| enough elements.</p> |
| <p><code>IntoChunks</code> is based on <code>GroupBy</code>: it is iterable (implements |
| <code>IntoIterator</code>, <strong>not</strong> <code>Iterator</code>), and it only buffers if several |
| chunk iterators are alive at the same time.</p> |
| <p>Iterator element type is <code>Chunk</code>, each chunk’s iterator.</p> |
| <p><strong>Panics</strong> if <code>size</code> is 0.</p> |
| |
| <div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>itertools::Itertools; |
| |
| <span class="kw">let </span>data = <span class="macro">vec!</span>[<span class="number">1</span>, <span class="number">1</span>, <span class="number">2</span>, -<span class="number">2</span>, <span class="number">6</span>, <span class="number">0</span>, <span class="number">3</span>, <span class="number">1</span>]; |
| <span class="comment">//chunk size=3 |------->|-------->|--->| |
| |
| // Note: The `&` is significant here, `IntoChunks` is iterable |
| // only by reference. You can also call `.into_iter()` explicitly. |
| </span><span class="kw">for </span>chunk <span class="kw">in </span><span class="kw-2">&</span>data.into_iter().chunks(<span class="number">3</span>) { |
| <span class="comment">// Check that the sum of each chunk is 4. |
| </span><span class="macro">assert_eq!</span>(<span class="number">4</span>, chunk.sum()); |
| }</code></pre></div> |
| </div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.tuple_windows" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#699-705">source</a><h4 class="code-header">fn <a href="#method.tuple_windows" class="fnname">tuple_windows</a><T>(self) -> <a class="struct" href="structs/struct.TupleWindows.html" title="struct itertools::structs::TupleWindows">TupleWindows</a><Self, T><span class="notable-traits"><span class="notable-traits-tooltip">ⓘ<span class="notable-traits-tooltiptext"><span class="docblock"><span class="notable">Notable traits for <a class="struct" href="structs/struct.TupleWindows.html" title="struct itertools::structs::TupleWindows">TupleWindows</a><I, T></span><code class="content"><span class="where fmt-newline">impl<I, T> Iterator for <a class="struct" href="structs/struct.TupleWindows.html" title="struct itertools::structs::TupleWindows">TupleWindows</a><I, T><span class="where fmt-newline">where<br> I: Iterator<Item = T::Item>,<br> T: <a class="trait" href="traits/trait.HomogeneousTuple.html" title="trait itertools::traits::HomogeneousTuple">HomogeneousTuple</a> + Clone,<br> T::Item: Clone,</span></span><span class="where fmt-newline"> type <a class="associatedtype">Item</a> = T;</span></code></span></span></span></span><span class="where fmt-newline">where<br> Self: Sized + Iterator<Item = T::Item>,<br> T: <a class="trait" href="traits/trait.HomogeneousTuple.html" title="trait itertools::traits::HomogeneousTuple">HomogeneousTuple</a>,<br> T::Item: Clone,</span></h4></section></summary><div class="docblock"><p>Return an iterator over all contiguous windows producing tuples of |
| a specific size (up to 12).</p> |
| <p><code>tuple_windows</code> 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.</p> |
| |
| <div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>itertools::Itertools; |
| <span class="kw">let </span><span class="kw-2">mut </span>v = Vec::new(); |
| |
| <span class="comment">// pairwise iteration |
| </span><span class="kw">for </span>(a, b) <span class="kw">in </span>(<span class="number">1</span>..<span class="number">5</span>).tuple_windows() { |
| v.push((a, b)); |
| } |
| <span class="macro">assert_eq!</span>(v, <span class="macro">vec!</span>[(<span class="number">1</span>, <span class="number">2</span>), (<span class="number">2</span>, <span class="number">3</span>), (<span class="number">3</span>, <span class="number">4</span>)]); |
| |
| <span class="kw">let </span><span class="kw-2">mut </span>it = (<span class="number">1</span>..<span class="number">5</span>).tuple_windows(); |
| <span class="macro">assert_eq!</span>(<span class="prelude-val">Some</span>((<span class="number">1</span>, <span class="number">2</span>, <span class="number">3</span>)), it.next()); |
| <span class="macro">assert_eq!</span>(<span class="prelude-val">Some</span>((<span class="number">2</span>, <span class="number">3</span>, <span class="number">4</span>)), it.next()); |
| <span class="macro">assert_eq!</span>(<span class="prelude-val">None</span>, it.next()); |
| |
| <span class="comment">// this requires a type hint |
| </span><span class="kw">let </span>it = (<span class="number">1</span>..<span class="number">5</span>).tuple_windows::<(<span class="kw">_</span>, <span class="kw">_</span>, <span class="kw">_</span>)>(); |
| itertools::assert_equal(it, <span class="macro">vec!</span>[(<span class="number">1</span>, <span class="number">2</span>, <span class="number">3</span>), (<span class="number">2</span>, <span class="number">3</span>, <span class="number">4</span>)]); |
| |
| <span class="comment">// you can also specify the complete type |
| </span><span class="kw">use </span>itertools::TupleWindows; |
| <span class="kw">use </span>std::ops::Range; |
| |
| <span class="kw">let </span>it: TupleWindows<Range<u32>, (u32, u32, u32)> = (<span class="number">1</span>..<span class="number">5</span>).tuple_windows(); |
| itertools::assert_equal(it, <span class="macro">vec!</span>[(<span class="number">1</span>, <span class="number">2</span>, <span class="number">3</span>), (<span class="number">2</span>, <span class="number">3</span>, <span class="number">4</span>)]);</code></pre></div> |
| </div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.circular_tuple_windows" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#734-740">source</a><h4 class="code-header">fn <a href="#method.circular_tuple_windows" class="fnname">circular_tuple_windows</a><T>(self) -> <a class="struct" href="structs/struct.CircularTupleWindows.html" title="struct itertools::structs::CircularTupleWindows">CircularTupleWindows</a><Self, T><span class="notable-traits"><span class="notable-traits-tooltip">ⓘ<span class="notable-traits-tooltiptext"><span class="docblock"><span class="notable">Notable traits for <a class="struct" href="structs/struct.CircularTupleWindows.html" title="struct itertools::structs::CircularTupleWindows">CircularTupleWindows</a><I, T></span><code class="content"><span class="where fmt-newline">impl<I, T> Iterator for <a class="struct" href="structs/struct.CircularTupleWindows.html" title="struct itertools::structs::CircularTupleWindows">CircularTupleWindows</a><I, T><span class="where fmt-newline">where<br> I: Iterator<Item = T::Item> + Clone,<br> T: TupleCollect + Clone,<br> T::Item: Clone,</span></span><span class="where fmt-newline"> type <a class="associatedtype">Item</a> = T;</span></code></span></span></span></span><span class="where fmt-newline">where<br> Self: Sized + Clone + Iterator<Item = T::Item> + ExactSizeIterator,<br> T: TupleCollect + Clone,<br> T::Item: Clone,</span></h4></section></summary><div class="docblock"><p>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).</p> |
| <p><code>circular_tuple_windows</code> 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.</p> |
| |
| <div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>itertools::Itertools; |
| <span class="kw">let </span><span class="kw-2">mut </span>v = Vec::new(); |
| <span class="kw">for </span>(a, b) <span class="kw">in </span>(<span class="number">1</span>..<span class="number">5</span>).circular_tuple_windows() { |
| v.push((a, b)); |
| } |
| <span class="macro">assert_eq!</span>(v, <span class="macro">vec!</span>[(<span class="number">1</span>, <span class="number">2</span>), (<span class="number">2</span>, <span class="number">3</span>), (<span class="number">3</span>, <span class="number">4</span>), (<span class="number">4</span>, <span class="number">1</span>)]); |
| |
| <span class="kw">let </span><span class="kw-2">mut </span>it = (<span class="number">1</span>..<span class="number">5</span>).circular_tuple_windows(); |
| <span class="macro">assert_eq!</span>(<span class="prelude-val">Some</span>((<span class="number">1</span>, <span class="number">2</span>, <span class="number">3</span>)), it.next()); |
| <span class="macro">assert_eq!</span>(<span class="prelude-val">Some</span>((<span class="number">2</span>, <span class="number">3</span>, <span class="number">4</span>)), it.next()); |
| <span class="macro">assert_eq!</span>(<span class="prelude-val">Some</span>((<span class="number">3</span>, <span class="number">4</span>, <span class="number">1</span>)), it.next()); |
| <span class="macro">assert_eq!</span>(<span class="prelude-val">Some</span>((<span class="number">4</span>, <span class="number">1</span>, <span class="number">2</span>)), it.next()); |
| <span class="macro">assert_eq!</span>(<span class="prelude-val">None</span>, it.next()); |
| |
| <span class="comment">// this requires a type hint |
| </span><span class="kw">let </span>it = (<span class="number">1</span>..<span class="number">5</span>).circular_tuple_windows::<(<span class="kw">_</span>, <span class="kw">_</span>, <span class="kw">_</span>)>(); |
| itertools::assert_equal(it, <span class="macro">vec!</span>[(<span class="number">1</span>, <span class="number">2</span>, <span class="number">3</span>), (<span class="number">2</span>, <span class="number">3</span>, <span class="number">4</span>), (<span class="number">3</span>, <span class="number">4</span>, <span class="number">1</span>), (<span class="number">4</span>, <span class="number">1</span>, <span class="number">2</span>)]);</code></pre></div> |
| </div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.tuples" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#772-777">source</a><h4 class="code-header">fn <a href="#method.tuples" class="fnname">tuples</a><T>(self) -> <a class="struct" href="structs/struct.Tuples.html" title="struct itertools::structs::Tuples">Tuples</a><Self, T><span class="notable-traits"><span class="notable-traits-tooltip">ⓘ<span class="notable-traits-tooltiptext"><span class="docblock"><span class="notable">Notable traits for <a class="struct" href="structs/struct.Tuples.html" title="struct itertools::structs::Tuples">Tuples</a><I, T></span><code class="content"><span class="where fmt-newline">impl<I, T> Iterator for <a class="struct" href="structs/struct.Tuples.html" title="struct itertools::structs::Tuples">Tuples</a><I, T><span class="where fmt-newline">where<br> I: Iterator<Item = T::Item>,<br> T: <a class="trait" href="traits/trait.HomogeneousTuple.html" title="trait itertools::traits::HomogeneousTuple">HomogeneousTuple</a>,</span></span><span class="where fmt-newline"> type <a class="associatedtype">Item</a> = T;</span></code></span></span></span></span><span class="where fmt-newline">where<br> Self: Sized + Iterator<Item = T::Item>,<br> T: <a class="trait" href="traits/trait.HomogeneousTuple.html" title="trait itertools::traits::HomogeneousTuple">HomogeneousTuple</a>,</span></h4></section></summary><div class="docblock"><p>Return an iterator that groups the items in tuples of a specific size |
| (up to 12).</p> |
| <p>See also the method <a href="trait.Itertools.html#method.next_tuple"><code>.next_tuple()</code></a>.</p> |
| |
| <div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>itertools::Itertools; |
| <span class="kw">let </span><span class="kw-2">mut </span>v = Vec::new(); |
| <span class="kw">for </span>(a, b) <span class="kw">in </span>(<span class="number">1</span>..<span class="number">5</span>).tuples() { |
| v.push((a, b)); |
| } |
| <span class="macro">assert_eq!</span>(v, <span class="macro">vec!</span>[(<span class="number">1</span>, <span class="number">2</span>), (<span class="number">3</span>, <span class="number">4</span>)]); |
| |
| <span class="kw">let </span><span class="kw-2">mut </span>it = (<span class="number">1</span>..<span class="number">7</span>).tuples(); |
| <span class="macro">assert_eq!</span>(<span class="prelude-val">Some</span>((<span class="number">1</span>, <span class="number">2</span>, <span class="number">3</span>)), it.next()); |
| <span class="macro">assert_eq!</span>(<span class="prelude-val">Some</span>((<span class="number">4</span>, <span class="number">5</span>, <span class="number">6</span>)), it.next()); |
| <span class="macro">assert_eq!</span>(<span class="prelude-val">None</span>, it.next()); |
| |
| <span class="comment">// this requires a type hint |
| </span><span class="kw">let </span>it = (<span class="number">1</span>..<span class="number">7</span>).tuples::<(<span class="kw">_</span>, <span class="kw">_</span>, <span class="kw">_</span>)>(); |
| itertools::assert_equal(it, <span class="macro">vec!</span>[(<span class="number">1</span>, <span class="number">2</span>, <span class="number">3</span>), (<span class="number">4</span>, <span class="number">5</span>, <span class="number">6</span>)]); |
| |
| <span class="comment">// you can also specify the complete type |
| </span><span class="kw">use </span>itertools::Tuples; |
| <span class="kw">use </span>std::ops::Range; |
| |
| <span class="kw">let </span>it: Tuples<Range<u32>, (u32, u32, u32)> = (<span class="number">1</span>..<span class="number">7</span>).tuples(); |
| itertools::assert_equal(it, <span class="macro">vec!</span>[(<span class="number">1</span>, <span class="number">2</span>, <span class="number">3</span>), (<span class="number">4</span>, <span class="number">5</span>, <span class="number">6</span>)]);</code></pre></div> |
| <p>See also <a href="structs/struct.Tuples.html#method.into_buffer" title="Tuples::into_buffer"><code>Tuples::into_buffer</code></a>.</p> |
| </div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.tee" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#797-802">source</a><h4 class="code-header">fn <a href="#method.tee" class="fnname">tee</a>(self) -> (<a class="struct" href="structs/struct.Tee.html" title="struct itertools::structs::Tee">Tee</a><Self>, <a class="struct" href="structs/struct.Tee.html" title="struct itertools::structs::Tee">Tee</a><Self>)<span class="where fmt-newline">where<br> Self: Sized,<br> Self::Item: Clone,</span></h4></section></summary><div class="docblock"><p>Split into an iterator pair that both yield all elements from |
| the original iterator.</p> |
| <p><strong>Note:</strong> If the iterator is clonable, prefer using that instead |
| of using this method. Cloning is likely to be more efficient.</p> |
| <p>Iterator element type is <code>Self::Item</code>.</p> |
| |
| <div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>itertools::Itertools; |
| <span class="kw">let </span>xs = <span class="macro">vec!</span>[<span class="number">0</span>, <span class="number">1</span>, <span class="number">2</span>, <span class="number">3</span>]; |
| |
| <span class="kw">let </span>(<span class="kw-2">mut </span>t1, t2) = xs.into_iter().tee(); |
| itertools::assert_equal(t1.next(), <span class="prelude-val">Some</span>(<span class="number">0</span>)); |
| itertools::assert_equal(t2, <span class="number">0</span>..<span class="number">4</span>); |
| itertools::assert_equal(t1, <span class="number">1</span>..<span class="number">4</span>);</code></pre></div> |
| </div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.step" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#822-826">source</a><h4 class="code-header">fn <a href="#method.step" class="fnname">step</a>(self, n: usize) -> <a class="struct" href="structs/struct.Step.html" title="struct itertools::structs::Step">Step</a><Self><span class="notable-traits"><span class="notable-traits-tooltip">ⓘ<span class="notable-traits-tooltiptext"><span class="docblock"><span class="notable">Notable traits for <a class="struct" href="structs/struct.Step.html" title="struct itertools::structs::Step">Step</a><I></span><code class="content"><span class="where fmt-newline">impl<I> Iterator for <a class="struct" href="structs/struct.Step.html" title="struct itertools::structs::Step">Step</a><I><span class="where fmt-newline">where<br> I: Iterator,</span></span><span class="where fmt-newline"> type <a class="associatedtype">Item</a> = I::Item;</span></code></span></span></span></span><span class="where fmt-newline">where<br> Self: Sized,</span></h4></section></summary><span class="item-info"><div class="stab deprecated"><span class="emoji">👎</span><span>Deprecated since 0.8.0: Use std .step_by() instead</span></div></span><div class="docblock"><p>Return an iterator adaptor that steps <code>n</code> elements in the base iterator |
| for each iteration.</p> |
| <p>The iterator steps by yielding the next element from the base iterator, |
| then skipping forward <code>n - 1</code> elements.</p> |
| <p>Iterator element type is <code>Self::Item</code>.</p> |
| <p><strong>Panics</strong> if the step is 0.</p> |
| |
| <div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>itertools::Itertools; |
| |
| <span class="kw">let </span>it = (<span class="number">0</span>..<span class="number">8</span>).step(<span class="number">3</span>); |
| itertools::assert_equal(it, <span class="macro">vec!</span>[<span class="number">0</span>, <span class="number">3</span>, <span class="number">6</span>]);</code></pre></div> |
| </div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.map_into" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#835-840">source</a><h4 class="code-header">fn <a href="#method.map_into" class="fnname">map_into</a><R>(self) -> <a class="type" href="structs/type.MapInto.html" title="type itertools::structs::MapInto">MapInto</a><Self, R><span class="where fmt-newline">where<br> Self: Sized,<br> Self::Item: Into<R>,</span></h4></section></summary><div class="docblock"><p>Convert each item of the iterator using the [<code>Into</code>] trait.</p> |
| |
| <div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>itertools::Itertools; |
| |
| (<span class="number">1i32</span>..<span class="number">42i32</span>).map_into::<f64>().collect_vec();</code></pre></div> |
| </div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.map_results" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#844-849">source</a><h4 class="code-header">fn <a href="#method.map_results" class="fnname">map_results</a><F, T, U, E>(self, f: F) -> <a class="type" href="structs/type.MapOk.html" title="type itertools::structs::MapOk">MapOk</a><Self, F><span class="where fmt-newline">where<br> Self: Iterator<Item = Result<T, E>> + Sized,<br> F: FnMut(T) -> U,</span></h4></section></summary><span class="item-info"><div class="stab deprecated"><span class="emoji">👎</span><span>Deprecated since 0.10.0: Use .map_ok() instead</span></div></span><div class="docblock"><p>See <a href="trait.Itertools.html#method.map_ok"><code>.map_ok()</code></a>.</p> |
| </div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.map_ok" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#862-867">source</a><h4 class="code-header">fn <a href="#method.map_ok" class="fnname">map_ok</a><F, T, U, E>(self, f: F) -> <a class="type" href="structs/type.MapOk.html" title="type itertools::structs::MapOk">MapOk</a><Self, F><span class="where fmt-newline">where<br> Self: Iterator<Item = Result<T, E>> + Sized,<br> F: FnMut(T) -> U,</span></h4></section></summary><div class="docblock"><p>Return an iterator adaptor that applies the provided closure |
| to every <code>Result::Ok</code> value. <code>Result::Err</code> values are |
| unchanged.</p> |
| |
| <div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>itertools::Itertools; |
| |
| <span class="kw">let </span>input = <span class="macro">vec!</span>[<span class="prelude-val">Ok</span>(<span class="number">41</span>), <span class="prelude-val">Err</span>(<span class="bool-val">false</span>), <span class="prelude-val">Ok</span>(<span class="number">11</span>)]; |
| <span class="kw">let </span>it = input.into_iter().map_ok(|i| i + <span class="number">1</span>); |
| itertools::assert_equal(it, <span class="macro">vec!</span>[<span class="prelude-val">Ok</span>(<span class="number">42</span>), <span class="prelude-val">Err</span>(<span class="bool-val">false</span>), <span class="prelude-val">Ok</span>(<span class="number">12</span>)]);</code></pre></div> |
| </div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.filter_ok" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#880-885">source</a><h4 class="code-header">fn <a href="#method.filter_ok" class="fnname">filter_ok</a><F, T, E>(self, f: F) -> <a class="struct" href="structs/struct.FilterOk.html" title="struct itertools::structs::FilterOk">FilterOk</a><Self, F><span class="notable-traits"><span class="notable-traits-tooltip">ⓘ<span class="notable-traits-tooltiptext"><span class="docblock"><span class="notable">Notable traits for <a class="struct" href="structs/struct.FilterOk.html" title="struct itertools::structs::FilterOk">FilterOk</a><I, F></span><code class="content"><span class="where fmt-newline">impl<I, F, T, E> Iterator for <a class="struct" href="structs/struct.FilterOk.html" title="struct itertools::structs::FilterOk">FilterOk</a><I, F><span class="where fmt-newline">where<br> I: Iterator<Item = Result<T, E>>,<br> F: FnMut(&T) -> bool,</span></span><span class="where fmt-newline"> type <a class="associatedtype">Item</a> = Result<T, E>;</span></code></span></span></span></span><span class="where fmt-newline">where<br> Self: Iterator<Item = Result<T, E>> + Sized,<br> F: FnMut(&T) -> bool,</span></h4></section></summary><div class="docblock"><p>Return an iterator adaptor that filters every <code>Result::Ok</code> |
| value with the provided closure. <code>Result::Err</code> values are |
| unchanged.</p> |
| |
| <div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>itertools::Itertools; |
| |
| <span class="kw">let </span>input = <span class="macro">vec!</span>[<span class="prelude-val">Ok</span>(<span class="number">22</span>), <span class="prelude-val">Err</span>(<span class="bool-val">false</span>), <span class="prelude-val">Ok</span>(<span class="number">11</span>)]; |
| <span class="kw">let </span>it = input.into_iter().filter_ok(|<span class="kw-2">&</span>i| i > <span class="number">20</span>); |
| itertools::assert_equal(it, <span class="macro">vec!</span>[<span class="prelude-val">Ok</span>(<span class="number">22</span>), <span class="prelude-val">Err</span>(<span class="bool-val">false</span>)]);</code></pre></div> |
| </div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.filter_map_ok" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#898-903">source</a><h4 class="code-header">fn <a href="#method.filter_map_ok" class="fnname">filter_map_ok</a><F, T, U, E>(self, f: F) -> <a class="struct" href="structs/struct.FilterMapOk.html" title="struct itertools::structs::FilterMapOk">FilterMapOk</a><Self, F><span class="notable-traits"><span class="notable-traits-tooltip">ⓘ<span class="notable-traits-tooltiptext"><span class="docblock"><span class="notable">Notable traits for <a class="struct" href="structs/struct.FilterMapOk.html" title="struct itertools::structs::FilterMapOk">FilterMapOk</a><I, F></span><code class="content"><span class="where fmt-newline">impl<I, F, T, U, E> Iterator for <a class="struct" href="structs/struct.FilterMapOk.html" title="struct itertools::structs::FilterMapOk">FilterMapOk</a><I, F><span class="where fmt-newline">where<br> I: Iterator<Item = Result<T, E>>,<br> F: FnMut(T) -> Option<U>,</span></span><span class="where fmt-newline"> type <a class="associatedtype">Item</a> = Result<U, E>;</span></code></span></span></span></span><span class="where fmt-newline">where<br> Self: Iterator<Item = Result<T, E>> + Sized,<br> F: FnMut(T) -> Option<U>,</span></h4></section></summary><div class="docblock"><p>Return an iterator adaptor that filters and transforms every |
| <code>Result::Ok</code> value with the provided closure. <code>Result::Err</code> |
| values are unchanged.</p> |
| |
| <div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>itertools::Itertools; |
| |
| <span class="kw">let </span>input = <span class="macro">vec!</span>[<span class="prelude-val">Ok</span>(<span class="number">22</span>), <span class="prelude-val">Err</span>(<span class="bool-val">false</span>), <span class="prelude-val">Ok</span>(<span class="number">11</span>)]; |
| <span class="kw">let </span>it = input.into_iter().filter_map_ok(|i| <span class="kw">if </span>i > <span class="number">20 </span>{ <span class="prelude-val">Some</span>(i * <span class="number">2</span>) } <span class="kw">else </span>{ <span class="prelude-val">None </span>}); |
| itertools::assert_equal(it, <span class="macro">vec!</span>[<span class="prelude-val">Ok</span>(<span class="number">44</span>), <span class="prelude-val">Err</span>(<span class="bool-val">false</span>)]);</code></pre></div> |
| </div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.flatten_ok" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#922-927">source</a><h4 class="code-header">fn <a href="#method.flatten_ok" class="fnname">flatten_ok</a><T, E>(self) -> <a class="struct" href="structs/struct.FlattenOk.html" title="struct itertools::structs::FlattenOk">FlattenOk</a><Self, T, E><span class="notable-traits"><span class="notable-traits-tooltip">ⓘ<span class="notable-traits-tooltiptext"><span class="docblock"><span class="notable">Notable traits for <a class="struct" href="structs/struct.FlattenOk.html" title="struct itertools::structs::FlattenOk">FlattenOk</a><I, T, E></span><code class="content"><span class="where fmt-newline">impl<I, T, E> Iterator for <a class="struct" href="structs/struct.FlattenOk.html" title="struct itertools::structs::FlattenOk">FlattenOk</a><I, T, E><span class="where fmt-newline">where<br> I: Iterator<Item = Result<T, E>>,<br> T: IntoIterator,</span></span><span class="where fmt-newline"> type <a class="associatedtype">Item</a> = Result<T::Item, E>;</span></code></span></span></span></span><span class="where fmt-newline">where<br> Self: Iterator<Item = Result<T, E>> + Sized,<br> T: IntoIterator,</span></h4></section></summary><div class="docblock"><p>Return an iterator adaptor that flattens every <code>Result::Ok</code> value into |
| a series of <code>Result::Ok</code> values. <code>Result::Err</code> values are unchanged.</p> |
| <p>This is useful when you have some common error type for your crate and |
| need to propagate it upwards, but the <code>Result::Ok</code> case needs to be flattened.</p> |
| |
| <div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>itertools::Itertools; |
| |
| <span class="kw">let </span>input = <span class="macro">vec!</span>[<span class="prelude-val">Ok</span>(<span class="number">0</span>..<span class="number">2</span>), <span class="prelude-val">Err</span>(<span class="bool-val">false</span>), <span class="prelude-val">Ok</span>(<span class="number">2</span>..<span class="number">4</span>)]; |
| <span class="kw">let </span>it = input.iter().cloned().flatten_ok(); |
| itertools::assert_equal(it.clone(), <span class="macro">vec!</span>[<span class="prelude-val">Ok</span>(<span class="number">0</span>), <span class="prelude-val">Ok</span>(<span class="number">1</span>), <span class="prelude-val">Err</span>(<span class="bool-val">false</span>), <span class="prelude-val">Ok</span>(<span class="number">2</span>), <span class="prelude-val">Ok</span>(<span class="number">3</span>)]); |
| |
| <span class="comment">// This can also be used to propagate errors when collecting. |
| </span><span class="kw">let </span>output_result: <span class="prelude-ty">Result</span><Vec<i32>, bool> = it.collect(); |
| <span class="macro">assert_eq!</span>(output_result, <span class="prelude-val">Err</span>(<span class="bool-val">false</span>));</code></pre></div> |
| </div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.merge" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#943-949">source</a><h4 class="code-header">fn <a href="#method.merge" class="fnname">merge</a><J>(self, other: J) -> <a class="type" href="structs/type.Merge.html" title="type itertools::structs::Merge">Merge</a><Self, J::IntoIter><span class="where fmt-newline">where<br> Self: Sized,<br> Self::Item: PartialOrd,<br> J: IntoIterator<Item = Self::Item>,</span></h4></section></summary><div class="docblock"><p>Return an iterator adaptor that merges the two base iterators in |
| ascending order. If both base iterators are sorted (ascending), the |
| result is sorted.</p> |
| <p>Iterator element type is <code>Self::Item</code>.</p> |
| |
| <div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>itertools::Itertools; |
| |
| <span class="kw">let </span>a = (<span class="number">0</span>..<span class="number">11</span>).step(<span class="number">3</span>); |
| <span class="kw">let </span>b = (<span class="number">0</span>..<span class="number">11</span>).step(<span class="number">5</span>); |
| <span class="kw">let </span>it = a.merge(b); |
| itertools::assert_equal(it, <span class="macro">vec!</span>[<span class="number">0</span>, <span class="number">0</span>, <span class="number">3</span>, <span class="number">5</span>, <span class="number">6</span>, <span class="number">9</span>, <span class="number">10</span>]);</code></pre></div> |
| </div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.merge_by" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#967-973">source</a><h4 class="code-header">fn <a href="#method.merge_by" class="fnname">merge_by</a><J, F>(self, other: J, is_first: F) -> <a class="struct" href="structs/struct.MergeBy.html" title="struct itertools::structs::MergeBy">MergeBy</a><Self, J::IntoIter, F><span class="notable-traits"><span class="notable-traits-tooltip">ⓘ<span class="notable-traits-tooltiptext"><span class="docblock"><span class="notable">Notable traits for <a class="struct" href="structs/struct.MergeBy.html" title="struct itertools::structs::MergeBy">MergeBy</a><I, J, F></span><code class="content"><span class="where fmt-newline">impl<I, J, F> Iterator for <a class="struct" href="structs/struct.MergeBy.html" title="struct itertools::structs::MergeBy">MergeBy</a><I, J, F><span class="where fmt-newline">where<br> I: Iterator,<br> J: Iterator<Item = I::Item>,<br> F: MergePredicate<I::Item>,</span></span><span class="where fmt-newline"> type <a class="associatedtype">Item</a> = I::Item;</span></code></span></span></span></span><span class="where fmt-newline">where<br> Self: Sized,<br> J: IntoIterator<Item = Self::Item>,<br> F: FnMut(&Self::Item, &Self::Item) -> bool,</span></h4></section></summary><div class="docblock"><p>Return an iterator adaptor that merges the two base iterators in order. |
| This is much like <a href="trait.Itertools.html#method.merge"><code>.merge()</code></a> but allows for a custom ordering.</p> |
| <p>This can be especially useful for sequences of tuples.</p> |
| <p>Iterator element type is <code>Self::Item</code>.</p> |
| |
| <div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>itertools::Itertools; |
| |
| <span class="kw">let </span>a = (<span class="number">0</span>..).zip(<span class="string">"bc"</span>.chars()); |
| <span class="kw">let </span>b = (<span class="number">0</span>..).zip(<span class="string">"ad"</span>.chars()); |
| <span class="kw">let </span>it = a.merge_by(b, |x, y| x.<span class="number">1 </span><= y.<span class="number">1</span>); |
| itertools::assert_equal(it, <span class="macro">vec!</span>[(<span class="number">0</span>, <span class="string">'a'</span>), (<span class="number">0</span>, <span class="string">'b'</span>), (<span class="number">1</span>, <span class="string">'c'</span>), (<span class="number">1</span>, <span class="string">'d'</span>)]);</code></pre></div> |
| </div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.merge_join_by" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#1003-1009">source</a><h4 class="code-header">fn <a href="#method.merge_join_by" class="fnname">merge_join_by</a><J, F>(<br> self,<br> other: J,<br> cmp_fn: F<br>) -> <a class="struct" href="structs/struct.MergeJoinBy.html" title="struct itertools::structs::MergeJoinBy">MergeJoinBy</a><Self, J::IntoIter, F><span class="notable-traits"><span class="notable-traits-tooltip">ⓘ<span class="notable-traits-tooltiptext"><span class="docblock"><span class="notable">Notable traits for <a class="struct" href="structs/struct.MergeJoinBy.html" title="struct itertools::structs::MergeJoinBy">MergeJoinBy</a><I, J, F></span><code class="content"><span class="where fmt-newline">impl<I, J, F> Iterator for <a class="struct" href="structs/struct.MergeJoinBy.html" title="struct itertools::structs::MergeJoinBy">MergeJoinBy</a><I, J, F><span class="where fmt-newline">where<br> I: Iterator,<br> J: Iterator,<br> F: FnMut(&I::Item, &J::Item) -> Ordering,</span></span><span class="where fmt-newline"> type <a class="associatedtype">Item</a> = <a class="enum" href="enum.EitherOrBoth.html" title="enum itertools::EitherOrBoth">EitherOrBoth</a><I::Item, J::Item>;</span></code></span></span></span></span><span class="where fmt-newline">where<br> J: IntoIterator,<br> F: FnMut(&Self::Item, &J::Item) -> Ordering,<br> Self: Sized,</span></h4></section></summary><div class="docblock"><p>Create an iterator that merges items from both this and the specified |
| iterator in ascending order.</p> |
| <p>It chooses whether to pair elements based on the <code>Ordering</code> returned by the |
| specified compare function. At any point, inspecting the tip of the |
| iterators <code>I</code> and <code>J</code> as items <code>i</code> of type <code>I::Item</code> and <code>j</code> of type |
| <code>J::Item</code> respectively, the resulting iterator will:</p> |
| <ul> |
| <li>Emit <code>EitherOrBoth::Left(i)</code> when <code>i < j</code>, |
| and remove <code>i</code> from its source iterator</li> |
| <li>Emit <code>EitherOrBoth::Right(j)</code> when <code>i > j</code>, |
| and remove <code>j</code> from its source iterator</li> |
| <li>Emit <code>EitherOrBoth::Both(i, j)</code> when <code>i == j</code>, |
| and remove both <code>i</code> and <code>j</code> from their respective source iterators</li> |
| </ul> |
| |
| <div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>itertools::Itertools; |
| <span class="kw">use </span>itertools::EitherOrBoth::{Left, Right, Both}; |
| |
| <span class="kw">let </span>multiples_of_2 = (<span class="number">0</span>..<span class="number">10</span>).step(<span class="number">2</span>); |
| <span class="kw">let </span>multiples_of_3 = (<span class="number">0</span>..<span class="number">10</span>).step(<span class="number">3</span>); |
| |
| itertools::assert_equal( |
| multiples_of_2.merge_join_by(multiples_of_3, |i, j| i.cmp(j)), |
| <span class="macro">vec!</span>[Both(<span class="number">0</span>, <span class="number">0</span>), Left(<span class="number">2</span>), Right(<span class="number">3</span>), Left(<span class="number">4</span>), Both(<span class="number">6</span>, <span class="number">6</span>), Left(<span class="number">8</span>), Right(<span class="number">9</span>)] |
| );</code></pre></div> |
| </div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.kmerge" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#1028-1034">source</a><h4 class="code-header">fn <a href="#method.kmerge" class="fnname">kmerge</a>(self) -> <a class="type" href="structs/type.KMerge.html" title="type itertools::structs::KMerge">KMerge</a><<Self::Item as IntoIterator>::IntoIter><span class="where fmt-newline">where<br> Self: Sized,<br> Self::Item: IntoIterator,<br> <Self::Item as IntoIterator>::Item: PartialOrd,</span></h4></section></summary><div class="docblock"><p>Return an iterator adaptor that flattens an iterator of iterators by |
| merging them in ascending order.</p> |
| <p>If all base iterators are sorted (ascending), the result is sorted.</p> |
| <p>Iterator element type is <code>Self::Item</code>.</p> |
| |
| <div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>itertools::Itertools; |
| |
| <span class="kw">let </span>a = (<span class="number">0</span>..<span class="number">6</span>).step(<span class="number">3</span>); |
| <span class="kw">let </span>b = (<span class="number">1</span>..<span class="number">6</span>).step(<span class="number">3</span>); |
| <span class="kw">let </span>c = (<span class="number">2</span>..<span class="number">6</span>).step(<span class="number">3</span>); |
| <span class="kw">let </span>it = <span class="macro">vec!</span>[a, b, c].into_iter().kmerge(); |
| itertools::assert_equal(it, <span class="macro">vec!</span>[<span class="number">0</span>, <span class="number">1</span>, <span class="number">2</span>, <span class="number">3</span>, <span class="number">4</span>, <span class="number">5</span>]);</code></pre></div> |
| </div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.kmerge_by" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#1057-1065">source</a><h4 class="code-header">fn <a href="#method.kmerge_by" class="fnname">kmerge_by</a><F>(<br> self,<br> first: F<br>) -> <a class="struct" href="structs/struct.KMergeBy.html" title="struct itertools::structs::KMergeBy">KMergeBy</a><<Self::Item as IntoIterator>::IntoIter, F><span class="notable-traits"><span class="notable-traits-tooltip">ⓘ<span class="notable-traits-tooltiptext"><span class="docblock"><span class="notable">Notable traits for <a class="struct" href="structs/struct.KMergeBy.html" title="struct itertools::structs::KMergeBy">KMergeBy</a><I, F></span><code class="content"><span class="where fmt-newline">impl<I, F> Iterator for <a class="struct" href="structs/struct.KMergeBy.html" title="struct itertools::structs::KMergeBy">KMergeBy</a><I, F><span class="where fmt-newline">where<br> I: Iterator,<br> F: KMergePredicate<I::Item>,</span></span><span class="where fmt-newline"> type <a class="associatedtype">Item</a> = I::Item;</span></code></span></span></span></span><span class="where fmt-newline">where<br> Self: Sized,<br> Self::Item: IntoIterator,<br> F: FnMut(&<Self::Item as IntoIterator>::Item, &<Self::Item as IntoIterator>::Item) -> bool,</span></h4></section></summary><div class="docblock"><p>Return an iterator adaptor that flattens an iterator of iterators by |
| merging them according to the given closure.</p> |
| <p>The closure <code>first</code> is called with two elements <em>a</em>, <em>b</em> and should |
| return <code>true</code> if <em>a</em> is ordered before <em>b</em>.</p> |
| <p>If all base iterators are sorted according to <code>first</code>, the result is |
| sorted.</p> |
| <p>Iterator element type is <code>Self::Item</code>.</p> |
| |
| <div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>itertools::Itertools; |
| |
| <span class="kw">let </span>a = <span class="macro">vec!</span>[-<span class="number">1f64</span>, <span class="number">2.</span>, <span class="number">3.</span>, -<span class="number">5.</span>, <span class="number">6.</span>, -<span class="number">7.</span>]; |
| <span class="kw">let </span>b = <span class="macro">vec!</span>[<span class="number">0.</span>, <span class="number">2.</span>, -<span class="number">4.</span>]; |
| <span class="kw">let </span><span class="kw-2">mut </span>it = <span class="macro">vec!</span>[a, b].into_iter().kmerge_by(|a, b| a.abs() < b.abs()); |
| <span class="macro">assert_eq!</span>(it.next(), <span class="prelude-val">Some</span>(<span class="number">0.</span>)); |
| <span class="macro">assert_eq!</span>(it.last(), <span class="prelude-val">Some</span>(-<span class="number">7.</span>));</code></pre></div> |
| </div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.cartesian_product" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#1078-1085">source</a><h4 class="code-header">fn <a href="#method.cartesian_product" class="fnname">cartesian_product</a><J>(self, other: J) -> <a class="struct" href="structs/struct.Product.html" title="struct itertools::structs::Product">Product</a><Self, J::IntoIter><span class="notable-traits"><span class="notable-traits-tooltip">ⓘ<span class="notable-traits-tooltiptext"><span class="docblock"><span class="notable">Notable traits for <a class="struct" href="structs/struct.Product.html" title="struct itertools::structs::Product">Product</a><I, J></span><code class="content"><span class="where fmt-newline">impl<I, J> Iterator for <a class="struct" href="structs/struct.Product.html" title="struct itertools::structs::Product">Product</a><I, J><span class="where fmt-newline">where<br> I: Iterator,<br> J: Clone + Iterator,<br> I::Item: Clone,</span></span><span class="where fmt-newline"> type <a class="associatedtype">Item</a> = (I::Item, J::Item);</span></code></span></span></span></span><span class="where fmt-newline">where<br> Self: Sized,<br> Self::Item: Clone,<br> J: IntoIterator,<br> J::IntoIter: Clone,</span></h4></section></summary><div class="docblock"><p>Return an iterator adaptor that iterates over the cartesian product of |
| the element sets of two iterators <code>self</code> and <code>J</code>.</p> |
| <p>Iterator element type is <code>(Self::Item, J::Item)</code>.</p> |
| |
| <div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>itertools::Itertools; |
| |
| <span class="kw">let </span>it = (<span class="number">0</span>..<span class="number">2</span>).cartesian_product(<span class="string">"αβ"</span>.chars()); |
| itertools::assert_equal(it, <span class="macro">vec!</span>[(<span class="number">0</span>, <span class="string">'α'</span>), (<span class="number">0</span>, <span class="string">'β'</span>), (<span class="number">1</span>, <span class="string">'α'</span>), (<span class="number">1</span>, <span class="string">'β'</span>)]);</code></pre></div> |
| </div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.multi_cartesian_product" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#1113-1120">source</a><h4 class="code-header">fn <a href="#method.multi_cartesian_product" class="fnname">multi_cartesian_product</a>(<br> self<br>) -> <a class="struct" href="structs/struct.MultiProduct.html" title="struct itertools::structs::MultiProduct">MultiProduct</a><<Self::Item as IntoIterator>::IntoIter><span class="notable-traits"><span class="notable-traits-tooltip">ⓘ<span class="notable-traits-tooltiptext"><span class="docblock"><span class="notable">Notable traits for <a class="struct" href="structs/struct.MultiProduct.html" title="struct itertools::structs::MultiProduct">MultiProduct</a><I></span><code class="content"><span class="where fmt-newline">impl<I> Iterator for <a class="struct" href="structs/struct.MultiProduct.html" title="struct itertools::structs::MultiProduct">MultiProduct</a><I><span class="where fmt-newline">where<br> I: Iterator + Clone,<br> I::Item: Clone,</span></span><span class="where fmt-newline"> type <a class="associatedtype">Item</a> = Vec<I::Item>;</span></code></span></span></span></span><span class="where fmt-newline">where<br> Self: Sized,<br> Self::Item: IntoIterator,<br> <Self::Item as IntoIterator>::IntoIter: Clone,<br> <Self::Item as IntoIterator>::Item: Clone,</span></h4></section></summary><div class="docblock"><p>Return an iterator adaptor that iterates over the cartesian product of |
| all subiterators returned by meta-iterator <code>self</code>.</p> |
| <p>All provided iterators must yield the same <code>Item</code> type. To generate |
| the product of iterators yielding multiple types, use the |
| <a href="macro.iproduct.html" title="iproduct"><code>iproduct</code></a> macro instead.</p> |
| <p>The iterator element type is <code>Vec<T></code>, where <code>T</code> is the iterator element |
| of the subiterators.</p> |
| |
| <div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>itertools::Itertools; |
| <span class="kw">let </span><span class="kw-2">mut </span>multi_prod = (<span class="number">0</span>..<span class="number">3</span>).map(|i| (i * <span class="number">2</span>)..(i * <span class="number">2 </span>+ <span class="number">2</span>)) |
| .multi_cartesian_product(); |
| <span class="macro">assert_eq!</span>(multi_prod.next(), <span class="prelude-val">Some</span>(<span class="macro">vec!</span>[<span class="number">0</span>, <span class="number">2</span>, <span class="number">4</span>])); |
| <span class="macro">assert_eq!</span>(multi_prod.next(), <span class="prelude-val">Some</span>(<span class="macro">vec!</span>[<span class="number">0</span>, <span class="number">2</span>, <span class="number">5</span>])); |
| <span class="macro">assert_eq!</span>(multi_prod.next(), <span class="prelude-val">Some</span>(<span class="macro">vec!</span>[<span class="number">0</span>, <span class="number">3</span>, <span class="number">4</span>])); |
| <span class="macro">assert_eq!</span>(multi_prod.next(), <span class="prelude-val">Some</span>(<span class="macro">vec!</span>[<span class="number">0</span>, <span class="number">3</span>, <span class="number">5</span>])); |
| <span class="macro">assert_eq!</span>(multi_prod.next(), <span class="prelude-val">Some</span>(<span class="macro">vec!</span>[<span class="number">1</span>, <span class="number">2</span>, <span class="number">4</span>])); |
| <span class="macro">assert_eq!</span>(multi_prod.next(), <span class="prelude-val">Some</span>(<span class="macro">vec!</span>[<span class="number">1</span>, <span class="number">2</span>, <span class="number">5</span>])); |
| <span class="macro">assert_eq!</span>(multi_prod.next(), <span class="prelude-val">Some</span>(<span class="macro">vec!</span>[<span class="number">1</span>, <span class="number">3</span>, <span class="number">4</span>])); |
| <span class="macro">assert_eq!</span>(multi_prod.next(), <span class="prelude-val">Some</span>(<span class="macro">vec!</span>[<span class="number">1</span>, <span class="number">3</span>, <span class="number">5</span>])); |
| <span class="macro">assert_eq!</span>(multi_prod.next(), <span class="prelude-val">None</span>);</code></pre></div> |
| </div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.coalesce" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#1150-1156">source</a><h4 class="code-header">fn <a href="#method.coalesce" class="fnname">coalesce</a><F>(self, f: F) -> <a class="type" href="structs/type.Coalesce.html" title="type itertools::structs::Coalesce">Coalesce</a><Self, F><span class="where fmt-newline">where<br> Self: Sized,<br> F: FnMut(Self::Item, Self::Item) -> Result<Self::Item, (Self::Item, Self::Item)>,</span></h4></section></summary><div class="docblock"><p>Return an iterator adaptor that uses the passed-in closure to |
| optionally merge together consecutive elements.</p> |
| <p>The closure <code>f</code> is passed two elements, <code>previous</code> and <code>current</code> and may |
| return either (1) <code>Ok(combined)</code> to merge the two values or |
| (2) <code>Err((previous', current'))</code> to indicate they can’t be merged. |
| In (2), the value <code>previous'</code> is emitted by the iterator. |
| Either (1) <code>combined</code> or (2) <code>current'</code> 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.</p> |
| <p>Iterator element type is <code>Self::Item</code>.</p> |
| <p>This iterator is <em>fused</em>.</p> |
| |
| <div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>itertools::Itertools; |
| |
| <span class="comment">// sum same-sign runs together |
| </span><span class="kw">let </span>data = <span class="macro">vec!</span>[-<span class="number">1.</span>, -<span class="number">2.</span>, -<span class="number">3.</span>, <span class="number">3.</span>, <span class="number">1.</span>, <span class="number">0.</span>, -<span class="number">1.</span>]; |
| itertools::assert_equal(data.into_iter().coalesce(|x, y| |
| <span class="kw">if </span>(x >= <span class="number">0.</span>) == (y >= <span class="number">0.</span>) { |
| <span class="prelude-val">Ok</span>(x + y) |
| } <span class="kw">else </span>{ |
| <span class="prelude-val">Err</span>((x, y)) |
| }), |
| <span class="macro">vec!</span>[-<span class="number">6.</span>, <span class="number">4.</span>, -<span class="number">1.</span>]);</code></pre></div> |
| </div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.dedup" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#1172-1177">source</a><h4 class="code-header">fn <a href="#method.dedup" class="fnname">dedup</a>(self) -> <a class="type" href="structs/type.Dedup.html" title="type itertools::structs::Dedup">Dedup</a><Self><span class="where fmt-newline">where<br> Self: Sized,<br> Self::Item: PartialEq,</span></h4></section></summary><div class="docblock"><p>Remove duplicates from sections of consecutive identical elements. |
| If the iterator is sorted, all elements will be unique.</p> |
| <p>Iterator element type is <code>Self::Item</code>.</p> |
| <p>This iterator is <em>fused</em>.</p> |
| |
| <div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>itertools::Itertools; |
| |
| <span class="kw">let </span>data = <span class="macro">vec!</span>[<span class="number">1.</span>, <span class="number">1.</span>, <span class="number">2.</span>, <span class="number">3.</span>, <span class="number">3.</span>, <span class="number">2.</span>, <span class="number">2.</span>]; |
| itertools::assert_equal(data.into_iter().dedup(), |
| <span class="macro">vec!</span>[<span class="number">1.</span>, <span class="number">2.</span>, <span class="number">3.</span>, <span class="number">2.</span>]);</code></pre></div> |
| </div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.dedup_by" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#1194-1199">source</a><h4 class="code-header">fn <a href="#method.dedup_by" class="fnname">dedup_by</a><Cmp>(self, cmp: Cmp) -> <a class="type" href="structs/type.DedupBy.html" title="type itertools::structs::DedupBy">DedupBy</a><Self, Cmp><span class="where fmt-newline">where<br> Self: Sized,<br> Cmp: FnMut(&Self::Item, &Self::Item) -> bool,</span></h4></section></summary><div class="docblock"><p>Remove duplicates from sections of consecutive identical elements, |
| determining equality using a comparison function. |
| If the iterator is sorted, all elements will be unique.</p> |
| <p>Iterator element type is <code>Self::Item</code>.</p> |
| <p>This iterator is <em>fused</em>.</p> |
| |
| <div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>itertools::Itertools; |
| |
| <span class="kw">let </span>data = <span class="macro">vec!</span>[(<span class="number">0</span>, <span class="number">1.</span>), (<span class="number">1</span>, <span class="number">1.</span>), (<span class="number">0</span>, <span class="number">2.</span>), (<span class="number">0</span>, <span class="number">3.</span>), (<span class="number">1</span>, <span class="number">3.</span>), (<span class="number">1</span>, <span class="number">2.</span>), (<span class="number">2</span>, <span class="number">2.</span>)]; |
| itertools::assert_equal(data.into_iter().dedup_by(|x, y| x.<span class="number">1 </span>== y.<span class="number">1</span>), |
| <span class="macro">vec!</span>[(<span class="number">0</span>, <span class="number">1.</span>), (<span class="number">0</span>, <span class="number">2.</span>), (<span class="number">0</span>, <span class="number">3.</span>), (<span class="number">1</span>, <span class="number">2.</span>)]);</code></pre></div> |
| </div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.dedup_with_count" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#1216-1221">source</a><h4 class="code-header">fn <a href="#method.dedup_with_count" class="fnname">dedup_with_count</a>(self) -> <a class="type" href="structs/type.DedupWithCount.html" title="type itertools::structs::DedupWithCount">DedupWithCount</a><Self><span class="where fmt-newline">where<br> Self: Sized,</span></h4></section></summary><div class="docblock"><p>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.</p> |
| <p>Iterator element type is <code>(usize, Self::Item)</code>.</p> |
| <p>This iterator is <em>fused</em>.</p> |
| |
| <div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>itertools::Itertools; |
| |
| <span class="kw">let </span>data = <span class="macro">vec!</span>[<span class="string">'a'</span>, <span class="string">'a'</span>, <span class="string">'b'</span>, <span class="string">'c'</span>, <span class="string">'c'</span>, <span class="string">'b'</span>, <span class="string">'b'</span>]; |
| itertools::assert_equal(data.into_iter().dedup_with_count(), |
| <span class="macro">vec!</span>[(<span class="number">2</span>, <span class="string">'a'</span>), (<span class="number">1</span>, <span class="string">'b'</span>), (<span class="number">2</span>, <span class="string">'c'</span>), (<span class="number">2</span>, <span class="string">'b'</span>)]);</code></pre></div> |
| </div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.dedup_by_with_count" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#1239-1245">source</a><h4 class="code-header">fn <a href="#method.dedup_by_with_count" class="fnname">dedup_by_with_count</a><Cmp>(self, cmp: Cmp) -> <a class="type" href="structs/type.DedupByWithCount.html" title="type itertools::structs::DedupByWithCount">DedupByWithCount</a><Self, Cmp><span class="where fmt-newline">where<br> Self: Sized,<br> Cmp: FnMut(&Self::Item, &Self::Item) -> bool,</span></h4></section></summary><div class="docblock"><p>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.</p> |
| <p>Iterator element type is <code>(usize, Self::Item)</code>.</p> |
| <p>This iterator is <em>fused</em>.</p> |
| |
| <div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>itertools::Itertools; |
| |
| <span class="kw">let </span>data = <span class="macro">vec!</span>[(<span class="number">0</span>, <span class="string">'a'</span>), (<span class="number">1</span>, <span class="string">'a'</span>), (<span class="number">0</span>, <span class="string">'b'</span>), (<span class="number">0</span>, <span class="string">'c'</span>), (<span class="number">1</span>, <span class="string">'c'</span>), (<span class="number">1</span>, <span class="string">'b'</span>), (<span class="number">2</span>, <span class="string">'b'</span>)]; |
| itertools::assert_equal(data.into_iter().dedup_by_with_count(|x, y| x.<span class="number">1 </span>== y.<span class="number">1</span>), |
| <span class="macro">vec!</span>[(<span class="number">2</span>, (<span class="number">0</span>, <span class="string">'a'</span>)), (<span class="number">1</span>, (<span class="number">0</span>, <span class="string">'b'</span>)), (<span class="number">2</span>, (<span class="number">0</span>, <span class="string">'c'</span>)), (<span class="number">2</span>, (<span class="number">1</span>, <span class="string">'b'</span>))]);</code></pre></div> |
| </div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.duplicates" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#1262-1267">source</a><h4 class="code-header">fn <a href="#method.duplicates" class="fnname">duplicates</a>(self) -> <a class="type" href="structs/type.Duplicates.html" title="type itertools::structs::Duplicates">Duplicates</a><Self><span class="where fmt-newline">where<br> Self: Sized,<br> Self::Item: Eq + Hash,</span></h4></section></summary><div class="docblock"><p>Return an iterator adaptor that produces elements that appear more than once during the |
| iteration. Duplicates are detected using hash and equality.</p> |
| <p>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.</p> |
| |
| <div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>itertools::Itertools; |
| |
| <span class="kw">let </span>data = <span class="macro">vec!</span>[<span class="number">10</span>, <span class="number">20</span>, <span class="number">30</span>, <span class="number">20</span>, <span class="number">40</span>, <span class="number">10</span>, <span class="number">50</span>]; |
| itertools::assert_equal(data.into_iter().duplicates(), |
| <span class="macro">vec!</span>[<span class="number">20</span>, <span class="number">10</span>]);</code></pre></div> |
| </div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.duplicates_by" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#1287-1293">source</a><h4 class="code-header">fn <a href="#method.duplicates_by" class="fnname">duplicates_by</a><V, F>(self, f: F) -> <a class="type" href="structs/type.DuplicatesBy.html" title="type itertools::structs::DuplicatesBy">DuplicatesBy</a><Self, V, F><span class="where fmt-newline">where<br> Self: Sized,<br> V: Eq + Hash,<br> F: FnMut(&Self::Item) -> V,</span></h4></section></summary><div class="docblock"><p>Return an iterator adaptor that produces elements that appear more than once during the |
| iteration. Duplicates are detected using hash and equality.</p> |
| <p>Duplicates are detected by comparing the key they map to with the keying function <code>f</code> by |
| hash and equality. The keys are stored in a hash map in the iterator.</p> |
| <p>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.</p> |
| |
| <div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>itertools::Itertools; |
| |
| <span class="kw">let </span>data = <span class="macro">vec!</span>[<span class="string">"a"</span>, <span class="string">"bb"</span>, <span class="string">"aa"</span>, <span class="string">"c"</span>, <span class="string">"ccc"</span>]; |
| itertools::assert_equal(data.into_iter().duplicates_by(|s| s.len()), |
| <span class="macro">vec!</span>[<span class="string">"aa"</span>, <span class="string">"c"</span>]);</code></pre></div> |
| </div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.unique" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#1314-1319">source</a><h4 class="code-header">fn <a href="#method.unique" class="fnname">unique</a>(self) -> <a class="struct" href="structs/struct.Unique.html" title="struct itertools::structs::Unique">Unique</a><Self><span class="notable-traits"><span class="notable-traits-tooltip">ⓘ<span class="notable-traits-tooltiptext"><span class="docblock"><span class="notable">Notable traits for <a class="struct" href="structs/struct.Unique.html" title="struct itertools::structs::Unique">Unique</a><I></span><code class="content"><span class="where fmt-newline">impl<I> Iterator for <a class="struct" href="structs/struct.Unique.html" title="struct itertools::structs::Unique">Unique</a><I><span class="where fmt-newline">where<br> I: Iterator,<br> I::Item: Eq + Hash + Clone,</span></span><span class="where fmt-newline"> type <a class="associatedtype">Item</a> = I::Item;</span></code></span></span></span></span><span class="where fmt-newline">where<br> Self: Sized,<br> Self::Item: Clone + Eq + Hash,</span></h4></section></summary><div class="docblock"><p>Return an iterator adaptor that filters out elements that have |
| already been produced once during the iteration. Duplicates |
| are detected using hash and equality.</p> |
| <p>Clones of visited elements are stored in a hash set in the |
| iterator.</p> |
| <p>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.</p> |
| |
| <div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>itertools::Itertools; |
| |
| <span class="kw">let </span>data = <span class="macro">vec!</span>[<span class="number">10</span>, <span class="number">20</span>, <span class="number">30</span>, <span class="number">20</span>, <span class="number">40</span>, <span class="number">10</span>, <span class="number">50</span>]; |
| itertools::assert_equal(data.into_iter().unique(), |
| <span class="macro">vec!</span>[<span class="number">10</span>, <span class="number">20</span>, <span class="number">30</span>, <span class="number">40</span>, <span class="number">50</span>]);</code></pre></div> |
| </div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.unique_by" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#1340-1346">source</a><h4 class="code-header">fn <a href="#method.unique_by" class="fnname">unique_by</a><V, F>(self, f: F) -> <a class="struct" href="structs/struct.UniqueBy.html" title="struct itertools::structs::UniqueBy">UniqueBy</a><Self, V, F><span class="notable-traits"><span class="notable-traits-tooltip">ⓘ<span class="notable-traits-tooltiptext"><span class="docblock"><span class="notable">Notable traits for <a class="struct" href="structs/struct.UniqueBy.html" title="struct itertools::structs::UniqueBy">UniqueBy</a><I, V, F></span><code class="content"><span class="where fmt-newline">impl<I, V, F> Iterator for <a class="struct" href="structs/struct.UniqueBy.html" title="struct itertools::structs::UniqueBy">UniqueBy</a><I, V, F><span class="where fmt-newline">where<br> I: Iterator,<br> V: Eq + Hash,<br> F: FnMut(&I::Item) -> V,</span></span><span class="where fmt-newline"> type <a class="associatedtype">Item</a> = I::Item;</span></code></span></span></span></span><span class="where fmt-newline">where<br> Self: Sized,<br> V: Eq + Hash,<br> F: FnMut(&Self::Item) -> V,</span></h4></section></summary><div class="docblock"><p>Return an iterator adaptor that filters out elements that have |
| already been produced once during the iteration.</p> |
| <p>Duplicates are detected by comparing the key they map to |
| with the keying function <code>f</code> by hash and equality. |
| The keys are stored in a hash set in the iterator.</p> |
| <p>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.</p> |
| |
| <div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>itertools::Itertools; |
| |
| <span class="kw">let </span>data = <span class="macro">vec!</span>[<span class="string">"a"</span>, <span class="string">"bb"</span>, <span class="string">"aa"</span>, <span class="string">"c"</span>, <span class="string">"ccc"</span>]; |
| itertools::assert_equal(data.into_iter().unique_by(|s| s.len()), |
| <span class="macro">vec!</span>[<span class="string">"a"</span>, <span class="string">"bb"</span>, <span class="string">"ccc"</span>]);</code></pre></div> |
| </div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.peeking_take_while" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#1360-1365">source</a><h4 class="code-header">fn <a href="#method.peeking_take_while" class="fnname">peeking_take_while</a><F>(&mut self, accept: F) -> <a class="struct" href="structs/struct.PeekingTakeWhile.html" title="struct itertools::structs::PeekingTakeWhile">PeekingTakeWhile</a><'_, Self, F><span class="notable-traits"><span class="notable-traits-tooltip">ⓘ<span class="notable-traits-tooltiptext"><span class="docblock"><span class="notable">Notable traits for <a class="struct" href="structs/struct.PeekingTakeWhile.html" title="struct itertools::structs::PeekingTakeWhile">PeekingTakeWhile</a><'a, I, F></span><code class="content"><span class="where fmt-newline">impl<'a, I, F> Iterator for <a class="struct" href="structs/struct.PeekingTakeWhile.html" title="struct itertools::structs::PeekingTakeWhile">PeekingTakeWhile</a><'a, I, F><span class="where fmt-newline">where<br> I: <a class="trait" href="trait.PeekingNext.html" title="trait itertools::PeekingNext">PeekingNext</a>,<br> F: FnMut(&I::Item) -> bool,</span></span><span class="where fmt-newline"> type <a class="associatedtype">Item</a> = I::Item;</span></code></span></span></span></span><span class="where fmt-newline">where<br> Self: Sized + <a class="trait" href="trait.PeekingNext.html" title="trait itertools::PeekingNext">PeekingNext</a>,<br> F: FnMut(&Self::Item) -> bool,</span></h4></section></summary><div class="docblock"><p>Return an iterator adaptor that borrows from this iterator and |
| takes items while the closure <code>accept</code> returns <code>true</code>.</p> |
| <p>This adaptor can only be used on iterators that implement <code>PeekingNext</code> |
| like <code>.peekable()</code>, <code>put_back</code> and a few other collection iterators.</p> |
| <p>The last and rejected element (first <code>false</code>) is still available when |
| <code>peeking_take_while</code> is done.</p> |
| <p>See also <a href="trait.Itertools.html#method.take_while_ref"><code>.take_while_ref()</code></a> |
| which is a similar adaptor.</p> |
| </div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.take_while_ref" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#1385-1390">source</a><h4 class="code-header">fn <a href="#method.take_while_ref" class="fnname">take_while_ref</a><F>(&mut self, accept: F) -> <a class="struct" href="structs/struct.TakeWhileRef.html" title="struct itertools::structs::TakeWhileRef">TakeWhileRef</a><'_, Self, F><span class="notable-traits"><span class="notable-traits-tooltip">ⓘ<span class="notable-traits-tooltiptext"><span class="docblock"><span class="notable">Notable traits for <a class="struct" href="structs/struct.TakeWhileRef.html" title="struct itertools::structs::TakeWhileRef">TakeWhileRef</a><'a, I, F></span><code class="content"><span class="where fmt-newline">impl<'a, I, F> Iterator for <a class="struct" href="structs/struct.TakeWhileRef.html" title="struct itertools::structs::TakeWhileRef">TakeWhileRef</a><'a, I, F><span class="where fmt-newline">where<br> I: Iterator + Clone,<br> F: FnMut(&I::Item) -> bool,</span></span><span class="where fmt-newline"> type <a class="associatedtype">Item</a> = I::Item;</span></code></span></span></span></span><span class="where fmt-newline">where<br> Self: Clone,<br> F: FnMut(&Self::Item) -> bool,</span></h4></section></summary><div class="docblock"><p>Return an iterator adaptor that borrows from a <code>Clone</code>-able iterator |
| to only pick off elements while the predicate <code>accept</code> returns <code>true</code>.</p> |
| <p>It uses the <code>Clone</code> trait to restore the original iterator so that the |
| last and rejected element (first <code>false</code>) is still available when |
| <code>take_while_ref</code> is done.</p> |
| |
| <div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>itertools::Itertools; |
| |
| <span class="kw">let </span><span class="kw-2">mut </span>hexadecimals = <span class="string">"0123456789abcdef"</span>.chars(); |
| |
| <span class="kw">let </span>decimals = hexadecimals.take_while_ref(|c| c.is_numeric()) |
| .collect::<String>(); |
| <span class="macro">assert_eq!</span>(decimals, <span class="string">"0123456789"</span>); |
| <span class="macro">assert_eq!</span>(hexadecimals.next(), <span class="prelude-val">Some</span>(<span class="string">'a'</span>)); |
| </code></pre></div> |
| </div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.while_some" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#1406-1410">source</a><h4 class="code-header">fn <a href="#method.while_some" class="fnname">while_some</a><A>(self) -> <a class="struct" href="structs/struct.WhileSome.html" title="struct itertools::structs::WhileSome">WhileSome</a><Self><span class="notable-traits"><span class="notable-traits-tooltip">ⓘ<span class="notable-traits-tooltiptext"><span class="docblock"><span class="notable">Notable traits for <a class="struct" href="structs/struct.WhileSome.html" title="struct itertools::structs::WhileSome">WhileSome</a><I></span><code class="content"><span class="where fmt-newline">impl<I, A> Iterator for <a class="struct" href="structs/struct.WhileSome.html" title="struct itertools::structs::WhileSome">WhileSome</a><I><span class="where fmt-newline">where<br> I: Iterator<Item = Option<A>>,</span></span><span class="where fmt-newline"> type <a class="associatedtype">Item</a> = A;</span></code></span></span></span></span><span class="where fmt-newline">where<br> Self: Sized + Iterator<Item = Option<A>>,</span></h4></section></summary><div class="docblock"><p>Return an iterator adaptor that filters <code>Option<A></code> iterator elements |
| and produces <code>A</code>. Stops on the first <code>None</code> encountered.</p> |
| <p>Iterator element type is <code>A</code>, the unwrapped element.</p> |
| |
| <div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>itertools::Itertools; |
| |
| <span class="comment">// List all hexadecimal digits |
| </span>itertools::assert_equal( |
| (<span class="number">0</span>..).map(|i| std::char::from_digit(i, <span class="number">16</span>)).while_some(), |
| <span class="string">"0123456789abcdef"</span>.chars()); |
| </code></pre></div> |
| </div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.tuple_combinations" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#1445-1451">source</a><h4 class="code-header">fn <a href="#method.tuple_combinations" class="fnname">tuple_combinations</a><T>(self) -> <a class="struct" href="structs/struct.TupleCombinations.html" title="struct itertools::structs::TupleCombinations">TupleCombinations</a><Self, T><span class="notable-traits"><span class="notable-traits-tooltip">ⓘ<span class="notable-traits-tooltiptext"><span class="docblock"><span class="notable">Notable traits for <a class="struct" href="structs/struct.TupleCombinations.html" title="struct itertools::structs::TupleCombinations">TupleCombinations</a><I, T></span><code class="content"><span class="where fmt-newline">impl<I, T> Iterator for <a class="struct" href="structs/struct.TupleCombinations.html" title="struct itertools::structs::TupleCombinations">TupleCombinations</a><I, T><span class="where fmt-newline">where<br> I: Iterator,<br> T: HasCombination<I>,</span></span><span class="where fmt-newline"> type <a class="associatedtype">Item</a> = T;</span></code></span></span></span></span><span class="where fmt-newline">where<br> Self: Sized + Clone,<br> Self::Item: Clone,<br> T: HasCombination<Self>,</span></h4></section></summary><div class="docblock"><p>Return an iterator adaptor that iterates over the combinations of the |
| elements from an iterator.</p> |
| <p>Iterator element can be any homogeneous tuple of type <code>Self::Item</code> with |
| size up to 12.</p> |
| |
| <div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>itertools::Itertools; |
| |
| <span class="kw">let </span><span class="kw-2">mut </span>v = Vec::new(); |
| <span class="kw">for </span>(a, b) <span class="kw">in </span>(<span class="number">1</span>..<span class="number">5</span>).tuple_combinations() { |
| v.push((a, b)); |
| } |
| <span class="macro">assert_eq!</span>(v, <span class="macro">vec!</span>[(<span class="number">1</span>, <span class="number">2</span>), (<span class="number">1</span>, <span class="number">3</span>), (<span class="number">1</span>, <span class="number">4</span>), (<span class="number">2</span>, <span class="number">3</span>), (<span class="number">2</span>, <span class="number">4</span>), (<span class="number">3</span>, <span class="number">4</span>)]); |
| |
| <span class="kw">let </span><span class="kw-2">mut </span>it = (<span class="number">1</span>..<span class="number">5</span>).tuple_combinations(); |
| <span class="macro">assert_eq!</span>(<span class="prelude-val">Some</span>((<span class="number">1</span>, <span class="number">2</span>, <span class="number">3</span>)), it.next()); |
| <span class="macro">assert_eq!</span>(<span class="prelude-val">Some</span>((<span class="number">1</span>, <span class="number">2</span>, <span class="number">4</span>)), it.next()); |
| <span class="macro">assert_eq!</span>(<span class="prelude-val">Some</span>((<span class="number">1</span>, <span class="number">3</span>, <span class="number">4</span>)), it.next()); |
| <span class="macro">assert_eq!</span>(<span class="prelude-val">Some</span>((<span class="number">2</span>, <span class="number">3</span>, <span class="number">4</span>)), it.next()); |
| <span class="macro">assert_eq!</span>(<span class="prelude-val">None</span>, it.next()); |
| |
| <span class="comment">// this requires a type hint |
| </span><span class="kw">let </span>it = (<span class="number">1</span>..<span class="number">5</span>).tuple_combinations::<(<span class="kw">_</span>, <span class="kw">_</span>, <span class="kw">_</span>)>(); |
| itertools::assert_equal(it, <span class="macro">vec!</span>[(<span class="number">1</span>, <span class="number">2</span>, <span class="number">3</span>), (<span class="number">1</span>, <span class="number">2</span>, <span class="number">4</span>), (<span class="number">1</span>, <span class="number">3</span>, <span class="number">4</span>), (<span class="number">2</span>, <span class="number">3</span>, <span class="number">4</span>)]); |
| |
| <span class="comment">// you can also specify the complete type |
| </span><span class="kw">use </span>itertools::TupleCombinations; |
| <span class="kw">use </span>std::ops::Range; |
| |
| <span class="kw">let </span>it: TupleCombinations<Range<u32>, (u32, u32, u32)> = (<span class="number">1</span>..<span class="number">5</span>).tuple_combinations(); |
| itertools::assert_equal(it, <span class="macro">vec!</span>[(<span class="number">1</span>, <span class="number">2</span>, <span class="number">3</span>), (<span class="number">1</span>, <span class="number">2</span>, <span class="number">4</span>), (<span class="number">1</span>, <span class="number">3</span>, <span class="number">4</span>), (<span class="number">2</span>, <span class="number">3</span>, <span class="number">4</span>)]);</code></pre></div> |
| </div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.combinations" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#1483-1488">source</a><h4 class="code-header">fn <a href="#method.combinations" class="fnname">combinations</a>(self, k: usize) -> <a class="struct" href="structs/struct.Combinations.html" title="struct itertools::structs::Combinations">Combinations</a><Self><span class="notable-traits"><span class="notable-traits-tooltip">ⓘ<span class="notable-traits-tooltiptext"><span class="docblock"><span class="notable">Notable traits for <a class="struct" href="structs/struct.Combinations.html" title="struct itertools::structs::Combinations">Combinations</a><I></span><code class="content"><span class="where fmt-newline">impl<I> Iterator for <a class="struct" href="structs/struct.Combinations.html" title="struct itertools::structs::Combinations">Combinations</a><I><span class="where fmt-newline">where<br> I: Iterator,<br> I::Item: Clone,</span></span><span class="where fmt-newline"> type <a class="associatedtype">Item</a> = Vec<I::Item>;</span></code></span></span></span></span><span class="where fmt-newline">where<br> Self: Sized,<br> Self::Item: Clone,</span></h4></section></summary><div class="docblock"><p>Return an iterator adaptor that iterates over the <code>k</code>-length combinations of |
| the elements from an iterator.</p> |
| <p>Iterator element type is <code>Vec<Self::Item></code>. The iterator produces a new Vec per iteration, |
| and clones the iterator elements.</p> |
| |
| <div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>itertools::Itertools; |
| |
| <span class="kw">let </span>it = (<span class="number">1</span>..<span class="number">5</span>).combinations(<span class="number">3</span>); |
| itertools::assert_equal(it, <span class="macro">vec!</span>[ |
| <span class="macro">vec!</span>[<span class="number">1</span>, <span class="number">2</span>, <span class="number">3</span>], |
| <span class="macro">vec!</span>[<span class="number">1</span>, <span class="number">2</span>, <span class="number">4</span>], |
| <span class="macro">vec!</span>[<span class="number">1</span>, <span class="number">3</span>, <span class="number">4</span>], |
| <span class="macro">vec!</span>[<span class="number">2</span>, <span class="number">3</span>, <span class="number">4</span>], |
| ]);</code></pre></div> |
| <p>Note: Combinations does not take into account the equality of the iterated values.</p> |
| |
| <div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>itertools::Itertools; |
| |
| <span class="kw">let </span>it = <span class="macro">vec!</span>[<span class="number">1</span>, <span class="number">2</span>, <span class="number">2</span>].into_iter().combinations(<span class="number">2</span>); |
| itertools::assert_equal(it, <span class="macro">vec!</span>[ |
| <span class="macro">vec!</span>[<span class="number">1</span>, <span class="number">2</span>], <span class="comment">// Note: these are the same |
| </span><span class="macro">vec!</span>[<span class="number">1</span>, <span class="number">2</span>], <span class="comment">// Note: these are the same |
| </span><span class="macro">vec!</span>[<span class="number">2</span>, <span class="number">2</span>], |
| ]);</code></pre></div> |
| </div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.combinations_with_replacement" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#1510-1516">source</a><h4 class="code-header">fn <a href="#method.combinations_with_replacement" class="fnname">combinations_with_replacement</a>(<br> self,<br> k: usize<br>) -> <a class="struct" href="structs/struct.CombinationsWithReplacement.html" title="struct itertools::structs::CombinationsWithReplacement">CombinationsWithReplacement</a><Self><span class="notable-traits"><span class="notable-traits-tooltip">ⓘ<span class="notable-traits-tooltiptext"><span class="docblock"><span class="notable">Notable traits for <a class="struct" href="structs/struct.CombinationsWithReplacement.html" title="struct itertools::structs::CombinationsWithReplacement">CombinationsWithReplacement</a><I></span><code class="content"><span class="where fmt-newline">impl<I> Iterator for <a class="struct" href="structs/struct.CombinationsWithReplacement.html" title="struct itertools::structs::CombinationsWithReplacement">CombinationsWithReplacement</a><I><span class="where fmt-newline">where<br> I: Iterator,<br> I::Item: Clone,</span></span><span class="where fmt-newline"> type <a class="associatedtype">Item</a> = Vec<I::Item>;</span></code></span></span></span></span><span class="where fmt-newline">where<br> Self: Sized,<br> Self::Item: Clone,</span></h4></section></summary><div class="docblock"><p>Return an iterator that iterates over the <code>k</code>-length combinations of |
| the elements from an iterator, with replacement.</p> |
| <p>Iterator element type is <code>Vec<Self::Item></code>. The iterator produces a new Vec per iteration, |
| and clones the iterator elements.</p> |
| |
| <div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>itertools::Itertools; |
| |
| <span class="kw">let </span>it = (<span class="number">1</span>..<span class="number">4</span>).combinations_with_replacement(<span class="number">2</span>); |
| itertools::assert_equal(it, <span class="macro">vec!</span>[ |
| <span class="macro">vec!</span>[<span class="number">1</span>, <span class="number">1</span>], |
| <span class="macro">vec!</span>[<span class="number">1</span>, <span class="number">2</span>], |
| <span class="macro">vec!</span>[<span class="number">1</span>, <span class="number">3</span>], |
| <span class="macro">vec!</span>[<span class="number">2</span>, <span class="number">2</span>], |
| <span class="macro">vec!</span>[<span class="number">2</span>, <span class="number">3</span>], |
| <span class="macro">vec!</span>[<span class="number">3</span>, <span class="number">3</span>], |
| ]);</code></pre></div> |
| </div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.permutations" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#1556-1561">source</a><h4 class="code-header">fn <a href="#method.permutations" class="fnname">permutations</a>(self, k: usize) -> <a class="struct" href="structs/struct.Permutations.html" title="struct itertools::structs::Permutations">Permutations</a><Self><span class="notable-traits"><span class="notable-traits-tooltip">ⓘ<span class="notable-traits-tooltiptext"><span class="docblock"><span class="notable">Notable traits for <a class="struct" href="structs/struct.Permutations.html" title="struct itertools::structs::Permutations">Permutations</a><I></span><code class="content"><span class="where fmt-newline">impl<I> Iterator for <a class="struct" href="structs/struct.Permutations.html" title="struct itertools::structs::Permutations">Permutations</a><I><span class="where fmt-newline">where<br> I: Iterator,<br> I::Item: Clone,</span></span><span class="where fmt-newline"> type <a class="associatedtype">Item</a> = Vec<I::Item>;</span></code></span></span></span></span><span class="where fmt-newline">where<br> Self: Sized,<br> Self::Item: Clone,</span></h4></section></summary><div class="docblock"><p>Return an iterator adaptor that iterates over all k-permutations of the |
| elements from an iterator.</p> |
| <p>Iterator element type is <code>Vec<Self::Item></code> with length <code>k</code>. The iterator |
| produces a new Vec per iteration, and clones the iterator elements.</p> |
| <p>If <code>k</code> is greater than the length of the input iterator, the resultant |
| iterator adaptor will be empty.</p> |
| |
| <div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>itertools::Itertools; |
| |
| <span class="kw">let </span>perms = (<span class="number">5</span>..<span class="number">8</span>).permutations(<span class="number">2</span>); |
| itertools::assert_equal(perms, <span class="macro">vec!</span>[ |
| <span class="macro">vec!</span>[<span class="number">5</span>, <span class="number">6</span>], |
| <span class="macro">vec!</span>[<span class="number">5</span>, <span class="number">7</span>], |
| <span class="macro">vec!</span>[<span class="number">6</span>, <span class="number">5</span>], |
| <span class="macro">vec!</span>[<span class="number">6</span>, <span class="number">7</span>], |
| <span class="macro">vec!</span>[<span class="number">7</span>, <span class="number">5</span>], |
| <span class="macro">vec!</span>[<span class="number">7</span>, <span class="number">6</span>], |
| ]);</code></pre></div> |
| <p>Note: Permutations does not take into account the equality of the iterated values.</p> |
| |
| <div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>itertools::Itertools; |
| |
| <span class="kw">let </span>it = <span class="macro">vec!</span>[<span class="number">2</span>, <span class="number">2</span>].into_iter().permutations(<span class="number">2</span>); |
| itertools::assert_equal(it, <span class="macro">vec!</span>[ |
| <span class="macro">vec!</span>[<span class="number">2</span>, <span class="number">2</span>], <span class="comment">// Note: these are the same |
| </span><span class="macro">vec!</span>[<span class="number">2</span>, <span class="number">2</span>], <span class="comment">// Note: these are the same |
| </span>]);</code></pre></div> |
| <p>Note: The source iterator is collected lazily, and will not be |
| re-iterated if the permutations adaptor is completed and re-iterated.</p> |
| </div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.powerset" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#1592-1597">source</a><h4 class="code-header">fn <a href="#method.powerset" class="fnname">powerset</a>(self) -> <a class="struct" href="structs/struct.Powerset.html" title="struct itertools::structs::Powerset">Powerset</a><Self><span class="notable-traits"><span class="notable-traits-tooltip">ⓘ<span class="notable-traits-tooltiptext"><span class="docblock"><span class="notable">Notable traits for <a class="struct" href="structs/struct.Powerset.html" title="struct itertools::structs::Powerset">Powerset</a><I></span><code class="content"><span class="where fmt-newline">impl<I> Iterator for <a class="struct" href="structs/struct.Powerset.html" title="struct itertools::structs::Powerset">Powerset</a><I><span class="where fmt-newline">where<br> I: Iterator,<br> I::Item: Clone,</span></span><span class="where fmt-newline"> type <a class="associatedtype">Item</a> = Vec<I::Item>;</span></code></span></span></span></span><span class="where fmt-newline">where<br> Self: Sized,<br> Self::Item: Clone,</span></h4></section></summary><div class="docblock"><p>Return an iterator that iterates through the powerset of the elements from an |
| iterator.</p> |
| <p>Iterator element type is <code>Vec<Self::Item></code>. The iterator produces a new <code>Vec</code> |
| per iteration, and clones the iterator elements.</p> |
| <p>The powerset of a set contains all subsets including the empty set and the full |
| input set. A powerset has length <em>2^n</em> where <em>n</em> is the length of the input |
| set.</p> |
| <p>Each <code>Vec</code> produced by this iterator represents a subset of the elements |
| produced by the source iterator.</p> |
| |
| <div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>itertools::Itertools; |
| |
| <span class="kw">let </span>sets = (<span class="number">1</span>..<span class="number">4</span>).powerset().collect::<Vec<<span class="kw">_</span>>>(); |
| itertools::assert_equal(sets, <span class="macro">vec!</span>[ |
| <span class="macro">vec!</span>[], |
| <span class="macro">vec!</span>[<span class="number">1</span>], |
| <span class="macro">vec!</span>[<span class="number">2</span>], |
| <span class="macro">vec!</span>[<span class="number">3</span>], |
| <span class="macro">vec!</span>[<span class="number">1</span>, <span class="number">2</span>], |
| <span class="macro">vec!</span>[<span class="number">1</span>, <span class="number">3</span>], |
| <span class="macro">vec!</span>[<span class="number">2</span>, <span class="number">3</span>], |
| <span class="macro">vec!</span>[<span class="number">1</span>, <span class="number">2</span>, <span class="number">3</span>], |
| ]);</code></pre></div> |
| </div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.pad_using" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#1616-1621">source</a><h4 class="code-header">fn <a href="#method.pad_using" class="fnname">pad_using</a><F>(self, min: usize, f: F) -> <a class="struct" href="structs/struct.PadUsing.html" title="struct itertools::structs::PadUsing">PadUsing</a><Self, F><span class="notable-traits"><span class="notable-traits-tooltip">ⓘ<span class="notable-traits-tooltiptext"><span class="docblock"><span class="notable">Notable traits for <a class="struct" href="structs/struct.PadUsing.html" title="struct itertools::structs::PadUsing">PadUsing</a><I, F></span><code class="content"><span class="where fmt-newline">impl<I, F> Iterator for <a class="struct" href="structs/struct.PadUsing.html" title="struct itertools::structs::PadUsing">PadUsing</a><I, F><span class="where fmt-newline">where<br> I: Iterator,<br> F: FnMut(usize) -> I::Item,</span></span><span class="where fmt-newline"> type <a class="associatedtype">Item</a> = I::Item;</span></code></span></span></span></span><span class="where fmt-newline">where<br> Self: Sized,<br> F: FnMut(usize) -> Self::Item,</span></h4></section></summary><div class="docblock"><p>Return an iterator adaptor that pads the sequence to a minimum length of |
| <code>min</code> by filling missing elements using a closure <code>f</code>.</p> |
| <p>Iterator element type is <code>Self::Item</code>.</p> |
| |
| <div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>itertools::Itertools; |
| |
| <span class="kw">let </span>it = (<span class="number">0</span>..<span class="number">5</span>).pad_using(<span class="number">10</span>, |i| <span class="number">2</span><span class="kw-2">*</span>i); |
| itertools::assert_equal(it, <span class="macro">vec!</span>[<span class="number">0</span>, <span class="number">1</span>, <span class="number">2</span>, <span class="number">3</span>, <span class="number">4</span>, <span class="number">10</span>, <span class="number">12</span>, <span class="number">14</span>, <span class="number">16</span>, <span class="number">18</span>]); |
| |
| <span class="kw">let </span>it = (<span class="number">0</span>..<span class="number">10</span>).pad_using(<span class="number">5</span>, |i| <span class="number">2</span><span class="kw-2">*</span>i); |
| itertools::assert_equal(it, <span class="macro">vec!</span>[<span class="number">0</span>, <span class="number">1</span>, <span class="number">2</span>, <span class="number">3</span>, <span class="number">4</span>, <span class="number">5</span>, <span class="number">6</span>, <span class="number">7</span>, <span class="number">8</span>, <span class="number">9</span>]); |
| |
| <span class="kw">let </span>it = (<span class="number">0</span>..<span class="number">5</span>).pad_using(<span class="number">10</span>, |i| <span class="number">2</span><span class="kw-2">*</span>i).rev(); |
| itertools::assert_equal(it, <span class="macro">vec!</span>[<span class="number">18</span>, <span class="number">16</span>, <span class="number">14</span>, <span class="number">12</span>, <span class="number">10</span>, <span class="number">4</span>, <span class="number">3</span>, <span class="number">2</span>, <span class="number">1</span>, <span class="number">0</span>]);</code></pre></div> |
| </div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.with_position" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#1642-1646">source</a><h4 class="code-header">fn <a href="#method.with_position" class="fnname">with_position</a>(self) -> <a class="struct" href="structs/struct.WithPosition.html" title="struct itertools::structs::WithPosition">WithPosition</a><Self><span class="notable-traits"><span class="notable-traits-tooltip">ⓘ<span class="notable-traits-tooltiptext"><span class="docblock"><span class="notable">Notable traits for <a class="struct" href="structs/struct.WithPosition.html" title="struct itertools::structs::WithPosition">WithPosition</a><I></span><code class="content"><span class="where fmt-newline">impl<I: Iterator> Iterator for <a class="struct" href="structs/struct.WithPosition.html" title="struct itertools::structs::WithPosition">WithPosition</a><I></span><span class="where fmt-newline"> type <a class="associatedtype">Item</a> = <a class="enum" href="enum.Position.html" title="enum itertools::Position">Position</a><I::Item>;</span></code></span></span></span></span><span class="where fmt-newline">where<br> Self: Sized,</span></h4></section></summary><div class="docblock"><p>Return an iterator adaptor that wraps each element in a <code>Position</code> to |
| ease special-case handling of the first or last elements.</p> |
| <p>Iterator element type is |
| <a href="enum.Position.html"><code>Position<Self::Item></code></a></p> |
| |
| <div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>itertools::{Itertools, Position}; |
| |
| <span class="kw">let </span>it = (<span class="number">0</span>..<span class="number">4</span>).with_position(); |
| itertools::assert_equal(it, |
| <span class="macro">vec!</span>[Position::First(<span class="number">0</span>), |
| Position::Middle(<span class="number">1</span>), |
| Position::Middle(<span class="number">2</span>), |
| Position::Last(<span class="number">3</span>)]); |
| |
| <span class="kw">let </span>it = (<span class="number">0</span>..<span class="number">1</span>).with_position(); |
| itertools::assert_equal(it, <span class="macro">vec!</span>[Position::Only(<span class="number">0</span>)]);</code></pre></div> |
| </div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.positions" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#1661-1666">source</a><h4 class="code-header">fn <a href="#method.positions" class="fnname">positions</a><P>(self, predicate: P) -> <a class="struct" href="structs/struct.Positions.html" title="struct itertools::structs::Positions">Positions</a><Self, P><span class="notable-traits"><span class="notable-traits-tooltip">ⓘ<span class="notable-traits-tooltiptext"><span class="docblock"><span class="notable">Notable traits for <a class="struct" href="structs/struct.Positions.html" title="struct itertools::structs::Positions">Positions</a><I, F></span><code class="content"><span class="where fmt-newline">impl<I, F> Iterator for <a class="struct" href="structs/struct.Positions.html" title="struct itertools::structs::Positions">Positions</a><I, F><span class="where fmt-newline">where<br> I: Iterator,<br> F: FnMut(I::Item) -> bool,</span></span><span class="where fmt-newline"> type <a class="associatedtype">Item</a> = usize;</span></code></span></span></span></span><span class="where fmt-newline">where<br> Self: Sized,<br> P: FnMut(Self::Item) -> bool,</span></h4></section></summary><div class="docblock"><p>Return an iterator adaptor that yields the indices of all elements |
| satisfying a predicate, counted from the start of the iterator.</p> |
| <p>Equivalent to <code>iter.enumerate().filter(|(_, v)| predicate(v)).map(|(i, _)| i)</code>.</p> |
| |
| <div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>itertools::Itertools; |
| |
| <span class="kw">let </span>data = <span class="macro">vec!</span>[<span class="number">1</span>, <span class="number">2</span>, <span class="number">3</span>, <span class="number">3</span>, <span class="number">4</span>, <span class="number">6</span>, <span class="number">7</span>, <span class="number">9</span>]; |
| itertools::assert_equal(data.iter().positions(|v| v % <span class="number">2 </span>== <span class="number">0</span>), <span class="macro">vec!</span>[<span class="number">1</span>, <span class="number">4</span>, <span class="number">5</span>]); |
| |
| itertools::assert_equal(data.iter().positions(|v| v % <span class="number">2 </span>== <span class="number">1</span>).rev(), <span class="macro">vec!</span>[<span class="number">7</span>, <span class="number">6</span>, <span class="number">3</span>, <span class="number">2</span>, <span class="number">0</span>]);</code></pre></div> |
| </div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.update" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#1678-1683">source</a><h4 class="code-header">fn <a href="#method.update" class="fnname">update</a><F>(self, updater: F) -> <a class="struct" href="structs/struct.Update.html" title="struct itertools::structs::Update">Update</a><Self, F><span class="notable-traits"><span class="notable-traits-tooltip">ⓘ<span class="notable-traits-tooltiptext"><span class="docblock"><span class="notable">Notable traits for <a class="struct" href="structs/struct.Update.html" title="struct itertools::structs::Update">Update</a><I, F></span><code class="content"><span class="where fmt-newline">impl<I, F> Iterator for <a class="struct" href="structs/struct.Update.html" title="struct itertools::structs::Update">Update</a><I, F><span class="where fmt-newline">where<br> I: Iterator,<br> F: FnMut(&mut I::Item),</span></span><span class="where fmt-newline"> type <a class="associatedtype">Item</a> = I::Item;</span></code></span></span></span></span><span class="where fmt-newline">where<br> Self: Sized,<br> F: FnMut(&mut Self::Item),</span></h4></section></summary><div class="docblock"><p>Return an iterator adaptor that applies a mutating function |
| to each element before yielding it.</p> |
| |
| <div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>itertools::Itertools; |
| |
| <span class="kw">let </span>input = <span class="macro">vec!</span>[<span class="macro">vec!</span>[<span class="number">1</span>], <span class="macro">vec!</span>[<span class="number">3</span>, <span class="number">2</span>, <span class="number">1</span>]]; |
| <span class="kw">let </span>it = input.into_iter().update(|<span class="kw-2">mut </span>v| v.push(<span class="number">0</span>)); |
| itertools::assert_equal(it, <span class="macro">vec!</span>[<span class="macro">vec!</span>[<span class="number">1</span>, <span class="number">0</span>], <span class="macro">vec!</span>[<span class="number">3</span>, <span class="number">2</span>, <span class="number">1</span>, <span class="number">0</span>]]);</code></pre></div> |
| </div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.next_tuple" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#1699-1704">source</a><h4 class="code-header">fn <a href="#method.next_tuple" class="fnname">next_tuple</a><T>(&mut self) -> Option<T><span class="where fmt-newline">where<br> Self: Sized + Iterator<Item = T::Item>,<br> T: <a class="trait" href="traits/trait.HomogeneousTuple.html" title="trait itertools::traits::HomogeneousTuple">HomogeneousTuple</a>,</span></h4></section></summary><div class="docblock"><p>Advances the iterator and returns the next items grouped in a tuple of |
| a specific size (up to 12).</p> |
| <p>If there are enough elements to be grouped in a tuple, then the tuple is |
| returned inside <code>Some</code>, otherwise <code>None</code> is returned.</p> |
| |
| <div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>itertools::Itertools; |
| |
| <span class="kw">let </span><span class="kw-2">mut </span>iter = <span class="number">1</span>..<span class="number">5</span>; |
| |
| <span class="macro">assert_eq!</span>(<span class="prelude-val">Some</span>((<span class="number">1</span>, <span class="number">2</span>)), iter.next_tuple());</code></pre></div> |
| </div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.collect_tuple" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#1724-1735">source</a><h4 class="code-header">fn <a href="#method.collect_tuple" class="fnname">collect_tuple</a><T>(self) -> Option<T><span class="where fmt-newline">where<br> Self: Sized + Iterator<Item = T::Item>,<br> T: <a class="trait" href="traits/trait.HomogeneousTuple.html" title="trait itertools::traits::HomogeneousTuple">HomogeneousTuple</a>,</span></h4></section></summary><div class="docblock"><p>Collects all items from the iterator into a tuple of a specific size |
| (up to 12).</p> |
| <p>If the number of elements inside the iterator is <strong>exactly</strong> equal to |
| the tuple size, then the tuple is returned inside <code>Some</code>, otherwise |
| <code>None</code> is returned.</p> |
| |
| <div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>itertools::Itertools; |
| |
| <span class="kw">let </span>iter = <span class="number">1</span>..<span class="number">3</span>; |
| |
| <span class="kw">if let </span><span class="prelude-val">Some</span>((x, y)) = iter.collect_tuple() { |
| <span class="macro">assert_eq!</span>((x, y), (<span class="number">1</span>, <span class="number">2</span>)) |
| } <span class="kw">else </span>{ |
| <span class="macro">panic!</span>(<span class="string">"Expected two elements"</span>) |
| }</code></pre></div> |
| </div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.find_position" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#1748-1757">source</a><h4 class="code-header">fn <a href="#method.find_position" class="fnname">find_position</a><P>(&mut self, pred: P) -> Option<(usize, Self::Item)><span class="where fmt-newline">where<br> P: FnMut(&Self::Item) -> bool,</span></h4></section></summary><div class="docblock"><p>Find the position and value of the first element satisfying a predicate.</p> |
| <p>The iterator is not advanced past the first element found.</p> |
| |
| <div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>itertools::Itertools; |
| |
| <span class="kw">let </span>text = <span class="string">"Hα"</span>; |
| <span class="macro">assert_eq!</span>(text.chars().find_position(|ch| ch.is_lowercase()), <span class="prelude-val">Some</span>((<span class="number">1</span>, <span class="string">'α'</span>)));</code></pre></div> |
| </div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.find_or_last" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#1770-1777">source</a><h4 class="code-header">fn <a href="#method.find_or_last" class="fnname">find_or_last</a><P>(self, predicate: P) -> Option<Self::Item><span class="where fmt-newline">where<br> Self: Sized,<br> P: FnMut(&Self::Item) -> bool,</span></h4></section></summary><div class="docblock"><p>Find the value of the first element satisfying a predicate or return the last element, if any.</p> |
| <p>The iterator is not advanced past the first element found.</p> |
| |
| <div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>itertools::Itertools; |
| |
| <span class="kw">let </span>numbers = [<span class="number">1</span>, <span class="number">2</span>, <span class="number">3</span>, <span class="number">4</span>]; |
| <span class="macro">assert_eq!</span>(numbers.iter().find_or_last(|&&x| x > <span class="number">5</span>), <span class="prelude-val">Some</span>(<span class="kw-2">&</span><span class="number">4</span>)); |
| <span class="macro">assert_eq!</span>(numbers.iter().find_or_last(|&&x| x > <span class="number">2</span>), <span class="prelude-val">Some</span>(<span class="kw-2">&</span><span class="number">3</span>)); |
| <span class="macro">assert_eq!</span>(std::iter::empty::<i32>().find_or_last(|<span class="kw-2">&</span>x| x > <span class="number">5</span>), <span class="prelude-val">None</span>);</code></pre></div> |
| </div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.find_or_first" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#1790-1800">source</a><h4 class="code-header">fn <a href="#method.find_or_first" class="fnname">find_or_first</a><P>(self, predicate: P) -> Option<Self::Item><span class="where fmt-newline">where<br> Self: Sized,<br> P: FnMut(&Self::Item) -> bool,</span></h4></section></summary><div class="docblock"><p>Find the value of the first element satisfying a predicate or return the first element, if any.</p> |
| <p>The iterator is not advanced past the first element found.</p> |
| |
| <div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>itertools::Itertools; |
| |
| <span class="kw">let </span>numbers = [<span class="number">1</span>, <span class="number">2</span>, <span class="number">3</span>, <span class="number">4</span>]; |
| <span class="macro">assert_eq!</span>(numbers.iter().find_or_first(|&&x| x > <span class="number">5</span>), <span class="prelude-val">Some</span>(<span class="kw-2">&</span><span class="number">1</span>)); |
| <span class="macro">assert_eq!</span>(numbers.iter().find_or_first(|&&x| x > <span class="number">2</span>), <span class="prelude-val">Some</span>(<span class="kw-2">&</span><span class="number">3</span>)); |
| <span class="macro">assert_eq!</span>(std::iter::empty::<i32>().find_or_first(|<span class="kw-2">&</span>x| x > <span class="number">5</span>), <span class="prelude-val">None</span>);</code></pre></div> |
| </div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.contains" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#1826-1833">source</a><h4 class="code-header">fn <a href="#method.contains" class="fnname">contains</a><Q>(&mut self, query: &Q) -> bool<span class="where fmt-newline">where<br> Self: Sized,<br> Self::Item: Borrow<Q>,<br> Q: PartialEq,</span></h4></section></summary><div class="docblock"><p>Returns <code>true</code> if the given item is present in this iterator.</p> |
| <p>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.</p> |
| |
| <div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>itertools::Itertools; |
| |
| <span class="attribute">#[derive(PartialEq, Debug)] |
| </span><span class="kw">enum </span>Enum { A, B, C, D, E, } |
| |
| <span class="kw">let </span><span class="kw-2">mut </span>iter = <span class="macro">vec!</span>[Enum::A, Enum::B, Enum::C, Enum::D].into_iter(); |
| |
| <span class="comment">// search `iter` for `B` |
| </span><span class="macro">assert_eq!</span>(iter.contains(<span class="kw-2">&</span>Enum::B), <span class="bool-val">true</span>); |
| <span class="comment">// `B` was found, so the iterator now rests at the item after `B` (i.e, `C`). |
| </span><span class="macro">assert_eq!</span>(iter.next(), <span class="prelude-val">Some</span>(Enum::C)); |
| |
| <span class="comment">// search `iter` for `E` |
| </span><span class="macro">assert_eq!</span>(iter.contains(<span class="kw-2">&</span>Enum::E), <span class="bool-val">false</span>); |
| <span class="comment">// `E` wasn't found, so `iter` is now exhausted |
| </span><span class="macro">assert_eq!</span>(iter.next(), <span class="prelude-val">None</span>);</code></pre></div> |
| </div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.all_equal" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#1851-1859">source</a><h4 class="code-header">fn <a href="#method.all_equal" class="fnname">all_equal</a>(&mut self) -> bool<span class="where fmt-newline">where<br> Self: Sized,<br> Self::Item: PartialEq,</span></h4></section></summary><div class="docblock"><p>Check whether all elements compare equal.</p> |
| <p>Empty iterators are considered to have equal elements:</p> |
| |
| <div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>itertools::Itertools; |
| |
| <span class="kw">let </span>data = <span class="macro">vec!</span>[<span class="number">1</span>, <span class="number">1</span>, <span class="number">1</span>, <span class="number">2</span>, <span class="number">2</span>, <span class="number">3</span>, <span class="number">3</span>, <span class="number">3</span>, <span class="number">4</span>, <span class="number">5</span>, <span class="number">5</span>]; |
| <span class="macro">assert!</span>(!data.iter().all_equal()); |
| <span class="macro">assert!</span>(data[<span class="number">0</span>..<span class="number">3</span>].iter().all_equal()); |
| <span class="macro">assert!</span>(data[<span class="number">3</span>..<span class="number">5</span>].iter().all_equal()); |
| <span class="macro">assert!</span>(data[<span class="number">5</span>..<span class="number">8</span>].iter().all_equal()); |
| |
| <span class="kw">let </span>data : <span class="prelude-ty">Option</span><usize> = <span class="prelude-val">None</span>; |
| <span class="macro">assert!</span>(data.into_iter().all_equal());</code></pre></div> |
| </div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.all_unique" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#1877-1883">source</a><h4 class="code-header">fn <a href="#method.all_unique" class="fnname">all_unique</a>(&mut self) -> bool<span class="where fmt-newline">where<br> Self: Sized,<br> Self::Item: Eq + Hash,</span></h4></section></summary><div class="docblock"><p>Check whether all elements are unique (non equal).</p> |
| <p>Empty iterators are considered to have unique elements:</p> |
| |
| <div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>itertools::Itertools; |
| |
| <span class="kw">let </span>data = <span class="macro">vec!</span>[<span class="number">1</span>, <span class="number">2</span>, <span class="number">3</span>, <span class="number">4</span>, <span class="number">1</span>, <span class="number">5</span>]; |
| <span class="macro">assert!</span>(!data.iter().all_unique()); |
| <span class="macro">assert!</span>(data[<span class="number">0</span>..<span class="number">4</span>].iter().all_unique()); |
| <span class="macro">assert!</span>(data[<span class="number">1</span>..<span class="number">6</span>].iter().all_unique()); |
| |
| <span class="kw">let </span>data : <span class="prelude-ty">Option</span><usize> = <span class="prelude-val">None</span>; |
| <span class="macro">assert!</span>(data.into_iter().all_unique());</code></pre></div> |
| </div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.dropping" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#1900-1907">source</a><h4 class="code-header">fn <a href="#method.dropping" class="fnname">dropping</a>(self, n: usize) -> Self<span class="where fmt-newline">where<br> Self: Sized,</span></h4></section></summary><div class="docblock"><p>Consume the first <code>n</code> elements from the iterator eagerly, |
| and return the same iterator again.</p> |
| <p>It works similarly to <em>.skip(</em> <code>n</code> <em>)</em> except it is eager and |
| preserves the iterator type.</p> |
| |
| <div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>itertools::Itertools; |
| |
| <span class="kw">let </span><span class="kw-2">mut </span>iter = <span class="string">"αβγ"</span>.chars().dropping(<span class="number">2</span>); |
| itertools::assert_equal(iter, <span class="string">"γ"</span>.chars());</code></pre></div> |
| <p><em>Fusing notes: if the iterator is exhausted by dropping, |
| the result of calling <code>.next()</code> again depends on the iterator implementation.</em></p> |
| </div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.dropping_back" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#1924-1932">source</a><h4 class="code-header">fn <a href="#method.dropping_back" class="fnname">dropping_back</a>(self, n: usize) -> Self<span class="where fmt-newline">where<br> Self: Sized,<br> Self: DoubleEndedIterator,</span></h4></section></summary><div class="docblock"><p>Consume the last <code>n</code> elements from the iterator eagerly, |
| and return the same iterator again.</p> |
| <p>This is only possible on double ended iterators. <code>n</code> may be |
| larger than the number of elements.</p> |
| <p>Note: This method is eager, dropping the back elements immediately and |
| preserves the iterator type.</p> |
| |
| <div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>itertools::Itertools; |
| |
| <span class="kw">let </span>init = <span class="macro">vec!</span>[<span class="number">0</span>, <span class="number">3</span>, <span class="number">6</span>, <span class="number">9</span>].into_iter().dropping_back(<span class="number">1</span>); |
| itertools::assert_equal(init, <span class="macro">vec!</span>[<span class="number">0</span>, <span class="number">3</span>, <span class="number">6</span>]);</code></pre></div> |
| </div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.foreach" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#1952-1957">source</a><h4 class="code-header">fn <a href="#method.foreach" class="fnname">foreach</a><F>(self, f: F)<span class="where fmt-newline">where<br> F: FnMut(Self::Item),<br> Self: Sized,</span></h4></section></summary><span class="item-info"><div class="stab deprecated"><span class="emoji">👎</span><span>Deprecated since 0.8.0: Use .for_each() instead</span></div></span><div class="docblock"><p>Run the closure <code>f</code> eagerly on each element of the iterator.</p> |
| <p>Consumes the iterator until its end.</p> |
| |
| <div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>std::sync::mpsc::channel; |
| <span class="kw">use </span>itertools::Itertools; |
| |
| <span class="kw">let </span>(tx, rx) = channel(); |
| |
| <span class="comment">// use .foreach() to apply a function to each value -- sending it |
| </span>(<span class="number">0</span>..<span class="number">5</span>).map(|x| x * <span class="number">2 </span>+ <span class="number">1</span>).foreach(|x| { tx.send(x).unwrap(); } ); |
| |
| drop(tx); |
| |
| itertools::assert_equal(rx.iter(), <span class="macro">vec!</span>[<span class="number">1</span>, <span class="number">3</span>, <span class="number">5</span>, <span class="number">7</span>, <span class="number">9</span>]);</code></pre></div> |
| </div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.concat" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#1972-1977">source</a><h4 class="code-header">fn <a href="#method.concat" class="fnname">concat</a>(self) -> Self::Item<span class="where fmt-newline">where<br> Self: Sized,<br> Self::Item: Extend<<<Self as Iterator>::Item as IntoIterator>::Item> + IntoIterator + Default,</span></h4></section></summary><div class="docblock"><p>Combine all an iterator’s elements into one element by using [<code>Extend</code>].</p> |
| <p>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 |
| <code>I::Item</code> is returned.</p> |
| |
| <div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>itertools::Itertools; |
| |
| <span class="kw">let </span>input = <span class="macro">vec!</span>[<span class="macro">vec!</span>[<span class="number">1</span>], <span class="macro">vec!</span>[<span class="number">2</span>, <span class="number">3</span>], <span class="macro">vec!</span>[<span class="number">4</span>, <span class="number">5</span>, <span class="number">6</span>]]; |
| <span class="macro">assert_eq!</span>(input.into_iter().concat(), |
| <span class="macro">vec!</span>[<span class="number">1</span>, <span class="number">2</span>, <span class="number">3</span>, <span class="number">4</span>, <span class="number">5</span>, <span class="number">6</span>]);</code></pre></div> |
| </div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.collect_vec" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#1982-1986">source</a><h4 class="code-header">fn <a href="#method.collect_vec" class="fnname">collect_vec</a>(self) -> Vec<Self::Item><span class="where fmt-newline">where<br> Self: Sized,</span></h4></section></summary><div class="docblock"><p><code>.collect_vec()</code> is simply a type specialization of [<code>Iterator::collect</code>], |
| for convenience.</p> |
| </div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.try_collect" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#2009-2015">source</a><h4 class="code-header">fn <a href="#method.try_collect" class="fnname">try_collect</a><T, U, E>(self) -> Result<U, E><span class="where fmt-newline">where<br> Self: Sized + Iterator<Item = Result<T, E>>,<br> Result<U, E>: FromIterator<Result<T, E>>,</span></h4></section></summary><div class="docblock"><p><code>.try_collect()</code> is more convenient way of writing |
| <code>.collect::<Result<_, _>>()</code></p> |
| <h5 id="example"><a href="#example">Example</a></h5> |
| <div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>std::{fs, io}; |
| <span class="kw">use </span>itertools::Itertools; |
| |
| <span class="kw">fn </span>process_dir_entries(entries: <span class="kw-2">&</span>[fs::DirEntry]) { |
| <span class="comment">// ... |
| </span>} |
| |
| <span class="kw">fn </span>do_stuff() -> std::io::Result<()> { |
| <span class="kw">let </span>entries: Vec<<span class="kw">_</span>> = fs::read_dir(<span class="string">"."</span>)<span class="question-mark">?</span>.try_collect()<span class="question-mark">?</span>; |
| process_dir_entries(<span class="kw-2">&</span>entries); |
| |
| <span class="prelude-val">Ok</span>(()) |
| }</code></pre></div> |
| </div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.set_from" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#2033-2046">source</a><h4 class="code-header">fn <a href="#method.set_from" class="fnname">set_from</a><'a, A: 'a, J>(&mut self, from: J) -> usize<span class="where fmt-newline">where<br> Self: Iterator<Item = &'a mut A>,<br> J: IntoIterator<Item = A>,</span></h4></section></summary><div class="docblock"><p>Assign to each reference in <code>self</code> from the <code>from</code> iterator, |
| stopping at the shortest of the two iterators.</p> |
| <p>The <code>from</code> iterator is queried for its next element before the <code>self</code> |
| iterator, and if either is exhausted the method is done.</p> |
| <p>Return the number of elements written.</p> |
| |
| <div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>itertools::Itertools; |
| |
| <span class="kw">let </span><span class="kw-2">mut </span>xs = [<span class="number">0</span>; <span class="number">4</span>]; |
| xs.iter_mut().set_from(<span class="number">1</span>..); |
| <span class="macro">assert_eq!</span>(xs, [<span class="number">1</span>, <span class="number">2</span>, <span class="number">3</span>, <span class="number">4</span>]);</code></pre></div> |
| </div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.join" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#2059-2076">source</a><h4 class="code-header">fn <a href="#method.join" class="fnname">join</a>(&mut self, sep: &str) -> String<span class="where fmt-newline">where<br> Self::Item: Display,</span></h4></section></summary><div class="docblock"><p>Combine all iterator elements into one String, separated by <code>sep</code>.</p> |
| <p>Use the <code>Display</code> implementation of each element.</p> |
| |
| <div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>itertools::Itertools; |
| |
| <span class="macro">assert_eq!</span>([<span class="string">"a"</span>, <span class="string">"b"</span>, <span class="string">"c"</span>].iter().join(<span class="string">", "</span>), <span class="string">"a, b, c"</span>); |
| <span class="macro">assert_eq!</span>([<span class="number">1</span>, <span class="number">2</span>, <span class="number">3</span>].iter().join(<span class="string">", "</span>), <span class="string">"1, 2, 3"</span>);</code></pre></div> |
| </div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.format" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#2093-2097">source</a><h4 class="code-header">fn <a href="#method.format" class="fnname">format</a>(self, sep: &str) -> <a class="struct" href="structs/struct.Format.html" title="struct itertools::structs::Format">Format</a><'_, Self><span class="where fmt-newline">where<br> Self: Sized,</span></h4></section></summary><div class="docblock"><p>Format all iterator elements, separated by <code>sep</code>.</p> |
| <p>All elements are formatted (any formatting trait) |
| with <code>sep</code> inserted between each element.</p> |
| <p><strong>Panics</strong> if the formatter helper is formatted more than once.</p> |
| |
| <div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>itertools::Itertools; |
| |
| <span class="kw">let </span>data = [<span class="number">1.1</span>, <span class="number">2.71828</span>, -<span class="number">3.</span>]; |
| <span class="macro">assert_eq!</span>( |
| <span class="macro">format!</span>(<span class="string">"{:.2}"</span>, data.iter().format(<span class="string">", "</span>)), |
| <span class="string">"1.10, 2.72, -3.00"</span>);</code></pre></div> |
| </div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.format_with" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#2131-2136">source</a><h4 class="code-header">fn <a href="#method.format_with" class="fnname">format_with</a><F>(self, sep: &str, format: F) -> <a class="struct" href="structs/struct.FormatWith.html" title="struct itertools::structs::FormatWith">FormatWith</a><'_, Self, F><span class="where fmt-newline">where<br> Self: Sized,<br> F: FnMut(Self::Item, &mut dyn FnMut(&dyn Display) -> Result) -> Result,</span></h4></section></summary><div class="docblock"><p>Format all iterator elements, separated by <code>sep</code>.</p> |
| <p>This is a customizable version of <a href="trait.Itertools.html#method.format"><code>.format()</code></a>.</p> |
| <p>The supplied closure <code>format</code> is called once per iterator element, |
| with two arguments: the element and a callback that takes a |
| <code>&Display</code> value, i.e. any reference to type that implements <code>Display</code>.</p> |
| <p>Using <code>&format_args!(...)</code> is the most versatile way to apply custom |
| element formatting. The callback can be called multiple times if needed.</p> |
| <p><strong>Panics</strong> if the formatter helper is formatted more than once.</p> |
| |
| <div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>itertools::Itertools; |
| |
| <span class="kw">let </span>data = [<span class="number">1.1</span>, <span class="number">2.71828</span>, -<span class="number">3.</span>]; |
| <span class="kw">let </span>data_formatter = data.iter().format_with(<span class="string">", "</span>, |elt, f| f(<span class="kw-2">&</span><span class="macro">format_args!</span>(<span class="string">"{:.2}"</span>, elt))); |
| <span class="macro">assert_eq!</span>(<span class="macro">format!</span>(<span class="string">"{}"</span>, data_formatter), |
| <span class="string">"1.10, 2.72, -3.00"</span>); |
| |
| <span class="comment">// .format_with() is recursively composable |
| </span><span class="kw">let </span>matrix = [[<span class="number">1.</span>, <span class="number">2.</span>, <span class="number">3.</span>], |
| [<span class="number">4.</span>, <span class="number">5.</span>, <span class="number">6.</span>]]; |
| <span class="kw">let </span>matrix_formatter = matrix.iter().format_with(<span class="string">"\n"</span>, |row, f| { |
| f(<span class="kw-2">&</span>row.iter().format_with(<span class="string">", "</span>, |elt, g| g(<span class="kw-2">&</span>elt))) |
| }); |
| <span class="macro">assert_eq!</span>(<span class="macro">format!</span>(<span class="string">"{}"</span>, matrix_formatter), |
| <span class="string">"1, 2, 3\n4, 5, 6"</span>); |
| |
| </code></pre></div> |
| </div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.fold_results" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#2140-2145">source</a><h4 class="code-header">fn <a href="#method.fold_results" class="fnname">fold_results</a><A, E, B, F>(&mut self, start: B, f: F) -> Result<B, E><span class="where fmt-newline">where<br> Self: Iterator<Item = Result<A, E>>,<br> F: FnMut(B, A) -> B,</span></h4></section></summary><span class="item-info"><div class="stab deprecated"><span class="emoji">👎</span><span>Deprecated since 0.10.0: Use .fold_ok() instead</span></div></span><div class="docblock"><p>See <a href="trait.Itertools.html#method.fold_ok"><code>.fold_ok()</code></a>.</p> |
| </div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.fold_ok" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#2189-2200">source</a><h4 class="code-header">fn <a href="#method.fold_ok" class="fnname">fold_ok</a><A, E, B, F>(&mut self, start: B, f: F) -> Result<B, E><span class="where fmt-newline">where<br> Self: Iterator<Item = Result<A, E>>,<br> F: FnMut(B, A) -> B,</span></h4></section></summary><div class="docblock"><p>Fold <code>Result</code> values from an iterator.</p> |
| <p>Only <code>Ok</code> values are folded. If no error is encountered, the folded |
| value is returned inside <code>Ok</code>. Otherwise, the operation terminates |
| and returns the first <code>Err</code> value it encounters. No iterator elements are |
| consumed after the first error.</p> |
| <p>The first accumulator value is the <code>start</code> parameter. |
| Each iteration passes the accumulator value and the next value inside <code>Ok</code> |
| to the fold function <code>f</code> and its return value becomes the new accumulator value.</p> |
| <p>For example the sequence <em>Ok(1), Ok(2), Ok(3)</em> will result in a |
| computation like this:</p> |
| |
| <div class="example-wrap ignore"><div class='tooltip'>ⓘ</div><pre class="rust rust-example-rendered"><code><span class="kw">let </span><span class="kw-2">mut </span>accum = start; |
| accum = f(accum, <span class="number">1</span>); |
| accum = f(accum, <span class="number">2</span>); |
| accum = f(accum, <span class="number">3</span>);</code></pre></div> |
| <p>With a <code>start</code> value of 0 and an addition as folding function, |
| this effectively results in <em>((0 + 1) + 2) + 3</em></p> |
| |
| <div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>std::ops::Add; |
| <span class="kw">use </span>itertools::Itertools; |
| |
| <span class="kw">let </span>values = [<span class="number">1</span>, <span class="number">2</span>, -<span class="number">2</span>, -<span class="number">1</span>, <span class="number">2</span>, <span class="number">1</span>]; |
| <span class="macro">assert_eq!</span>( |
| values.iter() |
| .map(<span class="prelude-val">Ok</span>::<<span class="kw">_</span>, ()>) |
| .fold_ok(<span class="number">0</span>, Add::add), |
| <span class="prelude-val">Ok</span>(<span class="number">3</span>) |
| ); |
| <span class="macro">assert!</span>( |
| values.iter() |
| .map(|<span class="kw-2">&</span>x| <span class="kw">if </span>x >= <span class="number">0 </span>{ <span class="prelude-val">Ok</span>(x) } <span class="kw">else </span>{ <span class="prelude-val">Err</span>(<span class="string">"Negative number"</span>) }) |
| .fold_ok(<span class="number">0</span>, Add::add) |
| .is_err() |
| );</code></pre></div> |
| </div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.fold_options" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#2221-2232">source</a><h4 class="code-header">fn <a href="#method.fold_options" class="fnname">fold_options</a><A, B, F>(&mut self, start: B, f: F) -> Option<B><span class="where fmt-newline">where<br> Self: Iterator<Item = Option<A>>,<br> F: FnMut(B, A) -> B,</span></h4></section></summary><div class="docblock"><p>Fold <code>Option</code> values from an iterator.</p> |
| <p>Only <code>Some</code> values are folded. If no <code>None</code> is encountered, the folded |
| value is returned inside <code>Some</code>. Otherwise, the operation terminates |
| and returns <code>None</code>. No iterator elements are consumed after the <code>None</code>.</p> |
| <p>This is the <code>Option</code> equivalent to <a href="trait.Itertools.html#method.fold_ok"><code>fold_ok</code></a>.</p> |
| |
| <div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>std::ops::Add; |
| <span class="kw">use </span>itertools::Itertools; |
| |
| <span class="kw">let </span><span class="kw-2">mut </span>values = <span class="macro">vec!</span>[<span class="prelude-val">Some</span>(<span class="number">1</span>), <span class="prelude-val">Some</span>(<span class="number">2</span>), <span class="prelude-val">Some</span>(-<span class="number">2</span>)].into_iter(); |
| <span class="macro">assert_eq!</span>(values.fold_options(<span class="number">5</span>, Add::add), <span class="prelude-val">Some</span>(<span class="number">5 </span>+ <span class="number">1 </span>+ <span class="number">2 </span>- <span class="number">2</span>)); |
| |
| <span class="kw">let </span><span class="kw-2">mut </span>more_values = <span class="macro">vec!</span>[<span class="prelude-val">Some</span>(<span class="number">2</span>), <span class="prelude-val">None</span>, <span class="prelude-val">Some</span>(<span class="number">0</span>)].into_iter(); |
| <span class="macro">assert!</span>(more_values.fold_options(<span class="number">0</span>, Add::add).is_none()); |
| <span class="macro">assert_eq!</span>(more_values.next().unwrap(), <span class="prelude-val">Some</span>(<span class="number">0</span>));</code></pre></div> |
| </div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.fold1" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#2247-2252">source</a><h4 class="code-header">fn <a href="#method.fold1" class="fnname">fold1</a><F>(self, f: F) -> Option<Self::Item><span class="where fmt-newline">where<br> F: FnMut(Self::Item, Self::Item) -> Self::Item,<br> Self: Sized,</span></h4></section></summary><span class="item-info"><div class="stab deprecated"><span class="emoji">👎</span><span>Deprecated since 0.10.2: Use <code>Iterator::reduce</code> instead</span></div></span><div class="docblock"><p>Accumulator of the elements in the iterator.</p> |
| <p>Like <code>.fold()</code>, without a base case. If the iterator is |
| empty, return <code>None</code>. With just one element, return it. |
| Otherwise elements are accumulated in sequence using the closure <code>f</code>.</p> |
| |
| <div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>itertools::Itertools; |
| |
| <span class="macro">assert_eq!</span>((<span class="number">0</span>..<span class="number">10</span>).fold1(|x, y| x + y).unwrap_or(<span class="number">0</span>), <span class="number">45</span>); |
| <span class="macro">assert_eq!</span>((<span class="number">0</span>..<span class="number">0</span>).fold1(|x, y| x * y), <span class="prelude-val">None</span>);</code></pre></div> |
| </div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.tree_fold1" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#2302-2359">source</a><h4 class="code-header">fn <a href="#method.tree_fold1" class="fnname">tree_fold1</a><F>(self, f: F) -> Option<Self::Item><span class="where fmt-newline">where<br> F: FnMut(Self::Item, Self::Item) -> Self::Item,<br> Self: Sized,</span></h4></section></summary><div class="docblock"><p>Accumulate the elements in the iterator in a tree-like manner.</p> |
| <p>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.</p> |
| <p>This produces a call tree like the following (where the calls under |
| an item are done after reading that item):</p> |
| <div class="example-wrap"><pre class="language-text"><code>1 2 3 4 5 6 7 |
| │ │ │ │ │ │ │ |
| └─f └─f └─f │ |
| │ │ │ │ |
| └───f └─f |
| │ │ |
| └─────f</code></pre></div> |
| <p>Which, for non-associative functions, will typically produce a different |
| result than the linear call tree used by [<code>Iterator::reduce</code>]:</p> |
| <div class="example-wrap"><pre class="language-text"><code>1 2 3 4 5 6 7 |
| │ │ │ │ │ │ │ |
| └─f─f─f─f─f─f</code></pre></div> |
| <p>If <code>f</code> is associative, prefer the normal [<code>Iterator::reduce</code>] instead.</p> |
| |
| <div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>itertools::Itertools; |
| |
| <span class="comment">// The same tree as above |
| </span><span class="kw">let </span>num_strings = (<span class="number">1</span>..<span class="number">8</span>).map(|x| x.to_string()); |
| <span class="macro">assert_eq!</span>(num_strings.tree_fold1(|x, y| <span class="macro">format!</span>(<span class="string">"f({}, {})"</span>, x, y)), |
| <span class="prelude-val">Some</span>(String::from(<span class="string">"f(f(f(1, 2), f(3, 4)), f(f(5, 6), 7))"</span>))); |
| |
| <span class="comment">// Like fold1, an empty iterator produces None |
| </span><span class="macro">assert_eq!</span>((<span class="number">0</span>..<span class="number">0</span>).tree_fold1(|x, y| x * y), <span class="prelude-val">None</span>); |
| |
| <span class="comment">// tree_fold1 matches fold1 for associative operations... |
| </span><span class="macro">assert_eq!</span>((<span class="number">0</span>..<span class="number">10</span>).tree_fold1(|x, y| x + y), |
| (<span class="number">0</span>..<span class="number">10</span>).fold1(|x, y| x + y)); |
| <span class="comment">// ...but not for non-associative ones |
| </span><span class="macro">assert_ne!</span>((<span class="number">0</span>..<span class="number">10</span>).tree_fold1(|x, y| x - y), |
| (<span class="number">0</span>..<span class="number">10</span>).fold1(|x, y| x - y));</code></pre></div> |
| </div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.fold_while" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#2400-2420">source</a><h4 class="code-header">fn <a href="#method.fold_while" class="fnname">fold_while</a><B, F>(&mut self, init: B, f: F) -> <a class="enum" href="enum.FoldWhile.html" title="enum itertools::FoldWhile">FoldWhile</a><B><span class="where fmt-newline">where<br> Self: Sized,<br> F: FnMut(B, Self::Item) -> <a class="enum" href="enum.FoldWhile.html" title="enum itertools::FoldWhile">FoldWhile</a><B>,</span></h4></section></summary><div class="docblock"><p>An iterator method that applies a function, producing a single, final value.</p> |
| <p><code>fold_while()</code> is basically equivalent to [<code>Iterator::fold</code>] but with additional support for |
| early exit via short-circuiting.</p> |
| |
| <div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>itertools::Itertools; |
| <span class="kw">use </span>itertools::FoldWhile::{Continue, Done}; |
| |
| <span class="kw">let </span>numbers = [<span class="number">1</span>, <span class="number">2</span>, <span class="number">3</span>, <span class="number">4</span>, <span class="number">5</span>, <span class="number">6</span>, <span class="number">7</span>, <span class="number">8</span>, <span class="number">9</span>, <span class="number">10</span>]; |
| |
| <span class="kw">let </span><span class="kw-2">mut </span>result = <span class="number">0</span>; |
| |
| <span class="comment">// for loop: |
| </span><span class="kw">for </span>i <span class="kw">in </span><span class="kw-2">&</span>numbers { |
| <span class="kw">if </span><span class="kw-2">*</span>i > <span class="number">5 </span>{ |
| <span class="kw">break</span>; |
| } |
| result = result + i; |
| } |
| |
| <span class="comment">// fold: |
| </span><span class="kw">let </span>result2 = numbers.iter().fold(<span class="number">0</span>, |acc, x| { |
| <span class="kw">if </span><span class="kw-2">*</span>x > <span class="number">5 </span>{ acc } <span class="kw">else </span>{ acc + x } |
| }); |
| |
| <span class="comment">// fold_while: |
| </span><span class="kw">let </span>result3 = numbers.iter().fold_while(<span class="number">0</span>, |acc, x| { |
| <span class="kw">if </span><span class="kw-2">*</span>x > <span class="number">5 </span>{ Done(acc) } <span class="kw">else </span>{ Continue(acc + x) } |
| }).into_inner(); |
| |
| <span class="comment">// they're the same |
| </span><span class="macro">assert_eq!</span>(result, result2); |
| <span class="macro">assert_eq!</span>(result2, result3);</code></pre></div> |
| <p>The big difference between the computations of <code>result2</code> and <code>result3</code> is that while |
| <code>fold()</code> called the provided closure for every item of the callee iterator, |
| <code>fold_while()</code> actually stopped iterating as soon as it encountered <code>Fold::Done(_)</code>.</p> |
| </div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.sum1" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#2443-2449">source</a><h4 class="code-header">fn <a href="#method.sum1" class="fnname">sum1</a><S>(self) -> Option<S><span class="where fmt-newline">where<br> Self: Sized,<br> S: Sum<Self::Item>,</span></h4></section></summary><div class="docblock"><p>Iterate over the entire iterator and add all the elements.</p> |
| <p>An empty iterator returns <code>None</code>, otherwise <code>Some(sum)</code>.</p> |
| <h5 id="panics"><a href="#panics">Panics</a></h5> |
| <p>When calling <code>sum1()</code> and a primitive integer type is being returned, this |
| method will panic if the computation overflows and debug assertions are |
| enabled.</p> |
| <h5 id="examples"><a href="#examples">Examples</a></h5> |
| <div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>itertools::Itertools; |
| |
| <span class="kw">let </span>empty_sum = (<span class="number">1</span>..<span class="number">1</span>).sum1::<i32>(); |
| <span class="macro">assert_eq!</span>(empty_sum, <span class="prelude-val">None</span>); |
| |
| <span class="kw">let </span>nonempty_sum = (<span class="number">1</span>..<span class="number">11</span>).sum1::<i32>(); |
| <span class="macro">assert_eq!</span>(nonempty_sum, <span class="prelude-val">Some</span>(<span class="number">55</span>));</code></pre></div> |
| </div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.product1" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#2471-2477">source</a><h4 class="code-header">fn <a href="#method.product1" class="fnname">product1</a><P>(self) -> Option<P><span class="where fmt-newline">where<br> Self: Sized,<br> P: Product<Self::Item>,</span></h4></section></summary><div class="docblock"><p>Iterate over the entire iterator and multiply all the elements.</p> |
| <p>An empty iterator returns <code>None</code>, otherwise <code>Some(product)</code>.</p> |
| <h5 id="panics-1"><a href="#panics-1">Panics</a></h5> |
| <p>When calling <code>product1()</code> and a primitive integer type is being returned, |
| method will panic if the computation overflows and debug assertions are |
| enabled.</p> |
| <h5 id="examples-1"><a href="#examples-1">Examples</a></h5> |
| <div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>itertools::Itertools; |
| |
| <span class="kw">let </span>empty_product = (<span class="number">1</span>..<span class="number">1</span>).product1::<i32>(); |
| <span class="macro">assert_eq!</span>(empty_product, <span class="prelude-val">None</span>); |
| |
| <span class="kw">let </span>nonempty_product = (<span class="number">1</span>..<span class="number">11</span>).product1::<i32>(); |
| <span class="macro">assert_eq!</span>(nonempty_product, <span class="prelude-val">Some</span>(<span class="number">3628800</span>));</code></pre></div> |
| </div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.sorted_unstable" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#2497-2506">source</a><h4 class="code-header">fn <a href="#method.sorted_unstable" class="fnname">sorted_unstable</a>(self) -> IntoIter<Self::Item><span class="where fmt-newline">where<br> Self: Sized,<br> Self::Item: Ord,</span></h4></section></summary><div class="docblock"><p>Sort all iterator elements into a new iterator in ascending order.</p> |
| <p><strong>Note:</strong> This consumes the entire iterator, uses the |
| [<code>slice::sort_unstable</code>] method and returns the result as a new |
| iterator that owns its elements.</p> |
| <p>The sorted iterator, if directly collected to a <code>Vec</code>, is converted |
| without any extra copying or allocation cost.</p> |
| |
| <div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>itertools::Itertools; |
| |
| <span class="comment">// sort the letters of the text in ascending order |
| </span><span class="kw">let </span>text = <span class="string">"bdacfe"</span>; |
| itertools::assert_equal(text.chars().sorted_unstable(), |
| <span class="string">"abcdef"</span>.chars());</code></pre></div> |
| </div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.sorted_unstable_by" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#2532-2539">source</a><h4 class="code-header">fn <a href="#method.sorted_unstable_by" class="fnname">sorted_unstable_by</a><F>(self, cmp: F) -> IntoIter<Self::Item><span class="where fmt-newline">where<br> Self: Sized,<br> F: FnMut(&Self::Item, &Self::Item) -> Ordering,</span></h4></section></summary><div class="docblock"><p>Sort all iterator elements into a new iterator in ascending order.</p> |
| <p><strong>Note:</strong> This consumes the entire iterator, uses the |
| [<code>slice::sort_unstable_by</code>] method and returns the result as a new |
| iterator that owns its elements.</p> |
| <p>The sorted iterator, if directly collected to a <code>Vec</code>, is converted |
| without any extra copying or allocation cost.</p> |
| |
| <div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>itertools::Itertools; |
| |
| <span class="comment">// sort people in descending order by age |
| </span><span class="kw">let </span>people = <span class="macro">vec!</span>[(<span class="string">"Jane"</span>, <span class="number">20</span>), (<span class="string">"John"</span>, <span class="number">18</span>), (<span class="string">"Jill"</span>, <span class="number">30</span>), (<span class="string">"Jack"</span>, <span class="number">27</span>)]; |
| |
| <span class="kw">let </span>oldest_people_first = people |
| .into_iter() |
| .sorted_unstable_by(|a, b| Ord::cmp(<span class="kw-2">&</span>b.<span class="number">1</span>, <span class="kw-2">&</span>a.<span class="number">1</span>)) |
| .map(|(person, _age)| person); |
| |
| itertools::assert_equal(oldest_people_first, |
| <span class="macro">vec!</span>[<span class="string">"Jill"</span>, <span class="string">"Jack"</span>, <span class="string">"Jane"</span>, <span class="string">"John"</span>]);</code></pre></div> |
| </div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.sorted_unstable_by_key" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#2565-2573">source</a><h4 class="code-header">fn <a href="#method.sorted_unstable_by_key" class="fnname">sorted_unstable_by_key</a><K, F>(self, f: F) -> IntoIter<Self::Item><span class="where fmt-newline">where<br> Self: Sized,<br> K: Ord,<br> F: FnMut(&Self::Item) -> K,</span></h4></section></summary><div class="docblock"><p>Sort all iterator elements into a new iterator in ascending order.</p> |
| <p><strong>Note:</strong> This consumes the entire iterator, uses the |
| [<code>slice::sort_unstable_by_key</code>] method and returns the result as a new |
| iterator that owns its elements.</p> |
| <p>The sorted iterator, if directly collected to a <code>Vec</code>, is converted |
| without any extra copying or allocation cost.</p> |
| |
| <div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>itertools::Itertools; |
| |
| <span class="comment">// sort people in descending order by age |
| </span><span class="kw">let </span>people = <span class="macro">vec!</span>[(<span class="string">"Jane"</span>, <span class="number">20</span>), (<span class="string">"John"</span>, <span class="number">18</span>), (<span class="string">"Jill"</span>, <span class="number">30</span>), (<span class="string">"Jack"</span>, <span class="number">27</span>)]; |
| |
| <span class="kw">let </span>oldest_people_first = people |
| .into_iter() |
| .sorted_unstable_by_key(|x| -x.<span class="number">1</span>) |
| .map(|(person, _age)| person); |
| |
| itertools::assert_equal(oldest_people_first, |
| <span class="macro">vec!</span>[<span class="string">"Jill"</span>, <span class="string">"Jack"</span>, <span class="string">"Jane"</span>, <span class="string">"John"</span>]);</code></pre></div> |
| </div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.sorted" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#2593-2602">source</a><h4 class="code-header">fn <a href="#method.sorted" class="fnname">sorted</a>(self) -> IntoIter<Self::Item><span class="where fmt-newline">where<br> Self: Sized,<br> Self::Item: Ord,</span></h4></section></summary><div class="docblock"><p>Sort all iterator elements into a new iterator in ascending order.</p> |
| <p><strong>Note:</strong> This consumes the entire iterator, uses the |
| [<code>slice::sort</code>] method and returns the result as a new |
| iterator that owns its elements.</p> |
| <p>The sorted iterator, if directly collected to a <code>Vec</code>, is converted |
| without any extra copying or allocation cost.</p> |
| |
| <div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>itertools::Itertools; |
| |
| <span class="comment">// sort the letters of the text in ascending order |
| </span><span class="kw">let </span>text = <span class="string">"bdacfe"</span>; |
| itertools::assert_equal(text.chars().sorted(), |
| <span class="string">"abcdef"</span>.chars());</code></pre></div> |
| </div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.sorted_by" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#2628-2635">source</a><h4 class="code-header">fn <a href="#method.sorted_by" class="fnname">sorted_by</a><F>(self, cmp: F) -> IntoIter<Self::Item><span class="where fmt-newline">where<br> Self: Sized,<br> F: FnMut(&Self::Item, &Self::Item) -> Ordering,</span></h4></section></summary><div class="docblock"><p>Sort all iterator elements into a new iterator in ascending order.</p> |
| <p><strong>Note:</strong> This consumes the entire iterator, uses the |
| [<code>slice::sort_by</code>] method and returns the result as a new |
| iterator that owns its elements.</p> |
| <p>The sorted iterator, if directly collected to a <code>Vec</code>, is converted |
| without any extra copying or allocation cost.</p> |
| |
| <div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>itertools::Itertools; |
| |
| <span class="comment">// sort people in descending order by age |
| </span><span class="kw">let </span>people = <span class="macro">vec!</span>[(<span class="string">"Jane"</span>, <span class="number">20</span>), (<span class="string">"John"</span>, <span class="number">18</span>), (<span class="string">"Jill"</span>, <span class="number">30</span>), (<span class="string">"Jack"</span>, <span class="number">27</span>)]; |
| |
| <span class="kw">let </span>oldest_people_first = people |
| .into_iter() |
| .sorted_by(|a, b| Ord::cmp(<span class="kw-2">&</span>b.<span class="number">1</span>, <span class="kw-2">&</span>a.<span class="number">1</span>)) |
| .map(|(person, _age)| person); |
| |
| itertools::assert_equal(oldest_people_first, |
| <span class="macro">vec!</span>[<span class="string">"Jill"</span>, <span class="string">"Jack"</span>, <span class="string">"Jane"</span>, <span class="string">"John"</span>]);</code></pre></div> |
| </div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.sorted_by_key" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#2661-2669">source</a><h4 class="code-header">fn <a href="#method.sorted_by_key" class="fnname">sorted_by_key</a><K, F>(self, f: F) -> IntoIter<Self::Item><span class="where fmt-newline">where<br> Self: Sized,<br> K: Ord,<br> F: FnMut(&Self::Item) -> K,</span></h4></section></summary><div class="docblock"><p>Sort all iterator elements into a new iterator in ascending order.</p> |
| <p><strong>Note:</strong> This consumes the entire iterator, uses the |
| [<code>slice::sort_by_key</code>] method and returns the result as a new |
| iterator that owns its elements.</p> |
| <p>The sorted iterator, if directly collected to a <code>Vec</code>, is converted |
| without any extra copying or allocation cost.</p> |
| |
| <div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>itertools::Itertools; |
| |
| <span class="comment">// sort people in descending order by age |
| </span><span class="kw">let </span>people = <span class="macro">vec!</span>[(<span class="string">"Jane"</span>, <span class="number">20</span>), (<span class="string">"John"</span>, <span class="number">18</span>), (<span class="string">"Jill"</span>, <span class="number">30</span>), (<span class="string">"Jack"</span>, <span class="number">27</span>)]; |
| |
| <span class="kw">let </span>oldest_people_first = people |
| .into_iter() |
| .sorted_by_key(|x| -x.<span class="number">1</span>) |
| .map(|(person, _age)| person); |
| |
| itertools::assert_equal(oldest_people_first, |
| <span class="macro">vec!</span>[<span class="string">"Jill"</span>, <span class="string">"Jack"</span>, <span class="string">"Jane"</span>, <span class="string">"John"</span>]);</code></pre></div> |
| </div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.sorted_by_cached_key" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#2696-2705">source</a><h4 class="code-header">fn <a href="#method.sorted_by_cached_key" class="fnname">sorted_by_cached_key</a><K, F>(self, f: F) -> IntoIter<Self::Item><span class="where fmt-newline">where<br> Self: Sized,<br> K: Ord,<br> F: FnMut(&Self::Item) -> K,</span></h4></section></summary><div class="docblock"><p>Sort all iterator elements into a new iterator in ascending order. The key function is |
| called exactly once per key.</p> |
| <p><strong>Note:</strong> This consumes the entire iterator, uses the |
| [<code>slice::sort_by_cached_key</code>] method and returns the result as a new |
| iterator that owns its elements.</p> |
| <p>The sorted iterator, if directly collected to a <code>Vec</code>, is converted |
| without any extra copying or allocation cost.</p> |
| |
| <div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>itertools::Itertools; |
| |
| <span class="comment">// sort people in descending order by age |
| </span><span class="kw">let </span>people = <span class="macro">vec!</span>[(<span class="string">"Jane"</span>, <span class="number">20</span>), (<span class="string">"John"</span>, <span class="number">18</span>), (<span class="string">"Jill"</span>, <span class="number">30</span>), (<span class="string">"Jack"</span>, <span class="number">27</span>)]; |
| |
| <span class="kw">let </span>oldest_people_first = people |
| .into_iter() |
| .sorted_by_cached_key(|x| -x.<span class="number">1</span>) |
| .map(|(person, _age)| person); |
| |
| itertools::assert_equal(oldest_people_first, |
| <span class="macro">vec!</span>[<span class="string">"Jill"</span>, <span class="string">"Jack"</span>, <span class="string">"Jane"</span>, <span class="string">"John"</span>]);</code></pre></div> |
| </div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.k_smallest" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#2735-2742">source</a><h4 class="code-header">fn <a href="#method.k_smallest" class="fnname">k_smallest</a>(self, k: usize) -> IntoIter<Self::Item><span class="where fmt-newline">where<br> Self: Sized,<br> Self::Item: Ord,</span></h4></section></summary><div class="docblock"><p>Sort the k smallest elements into a new iterator, in ascending order.</p> |
| <p><strong>Note:</strong> 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 <code>self.sorted()</code>.</p> |
| <p>This is guaranteed to use <code>k * sizeof(Self::Item) + O(1)</code> memory |
| and <code>O(n log k)</code> time, with <code>n</code> the number of elements in the input.</p> |
| <p>The sorted iterator, if directly collected to a <code>Vec</code>, is converted |
| without any extra copying or allocation cost.</p> |
| <p><strong>Note:</strong> This is functionally-equivalent to <code>self.sorted().take(k)</code> |
| but much more efficient.</p> |
| |
| <div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>itertools::Itertools; |
| |
| <span class="comment">// A random permutation of 0..15 |
| </span><span class="kw">let </span>numbers = <span class="macro">vec!</span>[<span class="number">6</span>, <span class="number">9</span>, <span class="number">1</span>, <span class="number">14</span>, <span class="number">0</span>, <span class="number">4</span>, <span class="number">8</span>, <span class="number">7</span>, <span class="number">11</span>, <span class="number">2</span>, <span class="number">10</span>, <span class="number">3</span>, <span class="number">13</span>, <span class="number">12</span>, <span class="number">5</span>]; |
| |
| <span class="kw">let </span>five_smallest = numbers |
| .into_iter() |
| .k_smallest(<span class="number">5</span>); |
| |
| itertools::assert_equal(five_smallest, <span class="number">0</span>..<span class="number">5</span>);</code></pre></div> |
| </div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.partition_map" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#2765-2780">source</a><h4 class="code-header">fn <a href="#method.partition_map" class="fnname">partition_map</a><A, B, F, L, R>(self, predicate: F) -> (A, B)<span class="where fmt-newline">where<br> Self: Sized,<br> F: FnMut(Self::Item) -> <a class="enum" href="enum.Either.html" title="enum itertools::Either">Either</a><L, R>,<br> A: Default + Extend<L>,<br> B: Default + Extend<R>,</span></h4></section></summary><div class="docblock"><p>Collect all iterator elements into one of two |
| partitions. Unlike [<code>Iterator::partition</code>], each partition may |
| have a distinct type.</p> |
| |
| <div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>itertools::{Itertools, Either}; |
| |
| <span class="kw">let </span>successes_and_failures = <span class="macro">vec!</span>[<span class="prelude-val">Ok</span>(<span class="number">1</span>), <span class="prelude-val">Err</span>(<span class="bool-val">false</span>), <span class="prelude-val">Err</span>(<span class="bool-val">true</span>), <span class="prelude-val">Ok</span>(<span class="number">2</span>)]; |
| |
| <span class="kw">let </span>(successes, failures): (Vec<<span class="kw">_</span>>, Vec<<span class="kw">_</span>>) = successes_and_failures |
| .into_iter() |
| .partition_map(|r| { |
| <span class="kw">match </span>r { |
| <span class="prelude-val">Ok</span>(v) => Either::Left(v), |
| <span class="prelude-val">Err</span>(v) => Either::Right(v), |
| } |
| }); |
| |
| <span class="macro">assert_eq!</span>(successes, [<span class="number">1</span>, <span class="number">2</span>]); |
| <span class="macro">assert_eq!</span>(failures, [<span class="bool-val">false</span>, <span class="bool-val">true</span>]);</code></pre></div> |
| </div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.partition_result" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#2797-2807">source</a><h4 class="code-header">fn <a href="#method.partition_result" class="fnname">partition_result</a><A, B, T, E>(self) -> (A, B)<span class="where fmt-newline">where<br> Self: Iterator<Item = Result<T, E>> + Sized,<br> A: Default + Extend<T>,<br> B: Default + Extend<E>,</span></h4></section></summary><div class="docblock"><p>Partition a sequence of <code>Result</code>s into one list of all the <code>Ok</code> elements |
| and another list of all the <code>Err</code> elements.</p> |
| |
| <div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>itertools::Itertools; |
| |
| <span class="kw">let </span>successes_and_failures = <span class="macro">vec!</span>[<span class="prelude-val">Ok</span>(<span class="number">1</span>), <span class="prelude-val">Err</span>(<span class="bool-val">false</span>), <span class="prelude-val">Err</span>(<span class="bool-val">true</span>), <span class="prelude-val">Ok</span>(<span class="number">2</span>)]; |
| |
| <span class="kw">let </span>(successes, failures): (Vec<<span class="kw">_</span>>, Vec<<span class="kw">_</span>>) = successes_and_failures |
| .into_iter() |
| .partition_result(); |
| |
| <span class="macro">assert_eq!</span>(successes, [<span class="number">1</span>, <span class="number">2</span>]); |
| <span class="macro">assert_eq!</span>(failures, [<span class="bool-val">false</span>, <span class="bool-val">true</span>]);</code></pre></div> |
| </div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.into_group_map" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#2826-2831">source</a><h4 class="code-header">fn <a href="#method.into_group_map" class="fnname">into_group_map</a><K, V>(self) -> HashMap<K, Vec<V>><span class="where fmt-newline">where<br> Self: Iterator<Item = (K, V)> + Sized,<br> K: Hash + Eq,</span></h4></section></summary><div class="docblock"><p>Return a <code>HashMap</code> of keys mapped to <code>Vec</code>s of values. Keys and values |
| are taken from <code>(Key, Value)</code> tuple pairs yielded by the input iterator.</p> |
| <p>Essentially a shorthand for <code>.into_grouping_map().collect::<Vec<_>>()</code>.</p> |
| |
| <div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>itertools::Itertools; |
| |
| <span class="kw">let </span>data = <span class="macro">vec!</span>[(<span class="number">0</span>, <span class="number">10</span>), (<span class="number">2</span>, <span class="number">12</span>), (<span class="number">3</span>, <span class="number">13</span>), (<span class="number">0</span>, <span class="number">20</span>), (<span class="number">3</span>, <span class="number">33</span>), (<span class="number">2</span>, <span class="number">42</span>)]; |
| <span class="kw">let </span>lookup = data.into_iter().into_group_map(); |
| |
| <span class="macro">assert_eq!</span>(lookup[<span class="kw-2">&</span><span class="number">0</span>], <span class="macro">vec!</span>[<span class="number">10</span>, <span class="number">20</span>]); |
| <span class="macro">assert_eq!</span>(lookup.get(<span class="kw-2">&</span><span class="number">1</span>), <span class="prelude-val">None</span>); |
| <span class="macro">assert_eq!</span>(lookup[<span class="kw-2">&</span><span class="number">2</span>], <span class="macro">vec!</span>[<span class="number">12</span>, <span class="number">42</span>]); |
| <span class="macro">assert_eq!</span>(lookup[<span class="kw-2">&</span><span class="number">3</span>], <span class="macro">vec!</span>[<span class="number">13</span>, <span class="number">33</span>]);</code></pre></div> |
| </div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.into_group_map_by" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#2861-2868">source</a><h4 class="code-header">fn <a href="#method.into_group_map_by" class="fnname">into_group_map_by</a><K, V, F>(self, f: F) -> HashMap<K, Vec<V>><span class="where fmt-newline">where<br> Self: Iterator<Item = V> + Sized,<br> K: Hash + Eq,<br> F: Fn(&V) -> K,</span></h4></section></summary><div class="docblock"><p>Return an <code>Iterator</code> on a <code>HashMap</code>. Keys mapped to <code>Vec</code>s of values. The key is specified |
| in the closure.</p> |
| <p>Essentially a shorthand for <code>.into_grouping_map_by(f).collect::<Vec<_>>()</code>.</p> |
| |
| <div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>itertools::Itertools; |
| <span class="kw">use </span>std::collections::HashMap; |
| |
| <span class="kw">let </span>data = <span class="macro">vec!</span>[(<span class="number">0</span>, <span class="number">10</span>), (<span class="number">2</span>, <span class="number">12</span>), (<span class="number">3</span>, <span class="number">13</span>), (<span class="number">0</span>, <span class="number">20</span>), (<span class="number">3</span>, <span class="number">33</span>), (<span class="number">2</span>, <span class="number">42</span>)]; |
| <span class="kw">let </span>lookup: HashMap<u32,Vec<(u32, u32)>> = |
| data.clone().into_iter().into_group_map_by(|a| a.<span class="number">0</span>); |
| |
| <span class="macro">assert_eq!</span>(lookup[<span class="kw-2">&</span><span class="number">0</span>], <span class="macro">vec!</span>[(<span class="number">0</span>,<span class="number">10</span>),(<span class="number">0</span>,<span class="number">20</span>)]); |
| <span class="macro">assert_eq!</span>(lookup.get(<span class="kw-2">&</span><span class="number">1</span>), <span class="prelude-val">None</span>); |
| <span class="macro">assert_eq!</span>(lookup[<span class="kw-2">&</span><span class="number">2</span>], <span class="macro">vec!</span>[(<span class="number">2</span>,<span class="number">12</span>), (<span class="number">2</span>,<span class="number">42</span>)]); |
| <span class="macro">assert_eq!</span>(lookup[<span class="kw-2">&</span><span class="number">3</span>], <span class="macro">vec!</span>[(<span class="number">3</span>,<span class="number">13</span>), (<span class="number">3</span>,<span class="number">33</span>)]); |
| |
| <span class="macro">assert_eq!</span>( |
| data.into_iter() |
| .into_group_map_by(|x| x.<span class="number">0</span>) |
| .into_iter() |
| .map(|(key, values)| (key, values.into_iter().fold(<span class="number">0</span>,|acc, (<span class="kw">_</span>,v)| acc + v ))) |
| .collect::<HashMap<u32,u32>>()[<span class="kw-2">&</span><span class="number">0</span>], |
| <span class="number">30</span>, |
| );</code></pre></div> |
| </div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.into_grouping_map" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#2880-2885">source</a><h4 class="code-header">fn <a href="#method.into_grouping_map" class="fnname">into_grouping_map</a><K, V>(self) -> <a class="struct" href="structs/struct.GroupingMap.html" title="struct itertools::structs::GroupingMap">GroupingMap</a><Self><span class="where fmt-newline">where<br> Self: Iterator<Item = (K, V)> + Sized,<br> K: Hash + Eq,</span></h4></section></summary><div class="docblock"><p>Constructs a <code>GroupingMap</code> to be used later with one of the efficient |
| group-and-fold operations it allows to perform.</p> |
| <p>The input iterator must yield item in the form of <code>(K, V)</code> where the |
| value of type <code>K</code> will be used as key to identify the groups and the |
| value of type <code>V</code> as value for the folding operation.</p> |
| <p>See <a href="structs/struct.GroupingMap.html" title="GroupingMap"><code>GroupingMap</code></a> for more informations |
| on what operations are available.</p> |
| </div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.into_grouping_map_by" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#2896-2902">source</a><h4 class="code-header">fn <a href="#method.into_grouping_map_by" class="fnname">into_grouping_map_by</a><K, V, F>(self, key_mapper: F) -> <a class="type" href="structs/type.GroupingMapBy.html" title="type itertools::structs::GroupingMapBy">GroupingMapBy</a><Self, F><span class="where fmt-newline">where<br> Self: Iterator<Item = V> + Sized,<br> K: Hash + Eq,<br> F: FnMut(&V) -> K,</span></h4></section></summary><div class="docblock"><p>Constructs a <code>GroupingMap</code> to be used later with one of the efficient |
| group-and-fold operations it allows to perform.</p> |
| <p>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 <code>key_mapper</code>.</p> |
| <p>See <a href="structs/struct.GroupingMap.html" title="GroupingMap"><code>GroupingMap</code></a> for more informations |
| on what operations are available.</p> |
| </div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.min_set" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#2927-2931">source</a><h4 class="code-header">fn <a href="#method.min_set" class="fnname">min_set</a>(self) -> Vec<Self::Item><span class="where fmt-newline">where<br> Self: Sized,<br> Self::Item: Ord,</span></h4></section></summary><div class="docblock"><p>Return all minimum elements of an iterator.</p> |
| <h5 id="examples-2"><a href="#examples-2">Examples</a></h5> |
| <div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>itertools::Itertools; |
| |
| <span class="kw">let </span>a: [i32; <span class="number">0</span>] = []; |
| <span class="macro">assert_eq!</span>(a.iter().min_set(), Vec::<<span class="kw-2">&</span>i32>::new()); |
| |
| <span class="kw">let </span>a = [<span class="number">1</span>]; |
| <span class="macro">assert_eq!</span>(a.iter().min_set(), <span class="macro">vec!</span>[<span class="kw-2">&</span><span class="number">1</span>]); |
| |
| <span class="kw">let </span>a = [<span class="number">1</span>, <span class="number">2</span>, <span class="number">3</span>, <span class="number">4</span>, <span class="number">5</span>]; |
| <span class="macro">assert_eq!</span>(a.iter().min_set(), <span class="macro">vec!</span>[<span class="kw-2">&</span><span class="number">1</span>]); |
| |
| <span class="kw">let </span>a = [<span class="number">1</span>, <span class="number">1</span>, <span class="number">1</span>, <span class="number">1</span>]; |
| <span class="macro">assert_eq!</span>(a.iter().min_set(), <span class="macro">vec!</span>[<span class="kw-2">&</span><span class="number">1</span>, <span class="kw-2">&</span><span class="number">1</span>, <span class="kw-2">&</span><span class="number">1</span>, <span class="kw-2">&</span><span class="number">1</span>]);</code></pre></div> |
| <p>The elements can be floats but no particular result is guaranteed |
| if an element is NaN.</p> |
| </div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.min_set_by" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#2958-2966">source</a><h4 class="code-header">fn <a href="#method.min_set_by" class="fnname">min_set_by</a><F>(self, compare: F) -> Vec<Self::Item><span class="where fmt-newline">where<br> Self: Sized,<br> F: FnMut(&Self::Item, &Self::Item) -> Ordering,</span></h4></section></summary><div class="docblock"><p>Return all minimum elements of an iterator, as determined by |
| the specified function.</p> |
| <h5 id="examples-3"><a href="#examples-3">Examples</a></h5> |
| <div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>itertools::Itertools; |
| |
| <span class="kw">let </span>a: [(i32, i32); <span class="number">0</span>] = []; |
| <span class="macro">assert_eq!</span>(a.iter().min_set_by(|<span class="kw">_</span>, <span class="kw">_</span>| Ordering::Equal), Vec::<<span class="kw-2">&</span>(i32, i32)>::new()); |
| |
| <span class="kw">let </span>a = [(<span class="number">1</span>, <span class="number">2</span>)]; |
| <span class="macro">assert_eq!</span>(a.iter().min_set_by(|&&(k1,<span class="kw">_</span>), &&(k2, <span class="kw">_</span>)| k1.cmp(<span class="kw-2">&</span>k2)), <span class="macro">vec!</span>[<span class="kw-2">&</span>(<span class="number">1</span>, <span class="number">2</span>)]); |
| |
| <span class="kw">let </span>a = [(<span class="number">1</span>, <span class="number">2</span>), (<span class="number">2</span>, <span class="number">2</span>), (<span class="number">3</span>, <span class="number">9</span>), (<span class="number">4</span>, <span class="number">8</span>), (<span class="number">5</span>, <span class="number">9</span>)]; |
| <span class="macro">assert_eq!</span>(a.iter().min_set_by(|&&(<span class="kw">_</span>,k1), &&(<span class="kw">_</span>,k2)| k1.cmp(<span class="kw-2">&</span>k2)), <span class="macro">vec!</span>[<span class="kw-2">&</span>(<span class="number">1</span>, <span class="number">2</span>), <span class="kw-2">&</span>(<span class="number">2</span>, <span class="number">2</span>)]); |
| |
| <span class="kw">let </span>a = [(<span class="number">1</span>, <span class="number">2</span>), (<span class="number">1</span>, <span class="number">3</span>), (<span class="number">1</span>, <span class="number">4</span>), (<span class="number">1</span>, <span class="number">5</span>)]; |
| <span class="macro">assert_eq!</span>(a.iter().min_set_by(|&&(k1,<span class="kw">_</span>), &&(k2, <span class="kw">_</span>)| k1.cmp(<span class="kw-2">&</span>k2)), <span class="macro">vec!</span>[<span class="kw-2">&</span>(<span class="number">1</span>, <span class="number">2</span>), <span class="kw-2">&</span>(<span class="number">1</span>, <span class="number">3</span>), <span class="kw-2">&</span>(<span class="number">1</span>, <span class="number">4</span>), <span class="kw-2">&</span>(<span class="number">1</span>, <span class="number">5</span>)]);</code></pre></div> |
| <p>The elements can be floats but no particular result is guaranteed |
| if an element is NaN.</p> |
| </div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.min_set_by_key" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#2992-2996">source</a><h4 class="code-header">fn <a href="#method.min_set_by_key" class="fnname">min_set_by_key</a><K, F>(self, key: F) -> Vec<Self::Item><span class="where fmt-newline">where<br> Self: Sized,<br> K: Ord,<br> F: FnMut(&Self::Item) -> K,</span></h4></section></summary><div class="docblock"><p>Return all minimum elements of an iterator, as determined by |
| the specified function.</p> |
| <h5 id="examples-4"><a href="#examples-4">Examples</a></h5> |
| <div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>itertools::Itertools; |
| |
| <span class="kw">let </span>a: [(i32, i32); <span class="number">0</span>] = []; |
| <span class="macro">assert_eq!</span>(a.iter().min_set_by_key(|<span class="kw">_</span>| ()), Vec::<<span class="kw-2">&</span>(i32, i32)>::new()); |
| |
| <span class="kw">let </span>a = [(<span class="number">1</span>, <span class="number">2</span>)]; |
| <span class="macro">assert_eq!</span>(a.iter().min_set_by_key(|&&(k,<span class="kw">_</span>)| k), <span class="macro">vec!</span>[<span class="kw-2">&</span>(<span class="number">1</span>, <span class="number">2</span>)]); |
| |
| <span class="kw">let </span>a = [(<span class="number">1</span>, <span class="number">2</span>), (<span class="number">2</span>, <span class="number">2</span>), (<span class="number">3</span>, <span class="number">9</span>), (<span class="number">4</span>, <span class="number">8</span>), (<span class="number">5</span>, <span class="number">9</span>)]; |
| <span class="macro">assert_eq!</span>(a.iter().min_set_by_key(|&&(<span class="kw">_</span>, k)| k), <span class="macro">vec!</span>[<span class="kw-2">&</span>(<span class="number">1</span>, <span class="number">2</span>), <span class="kw-2">&</span>(<span class="number">2</span>, <span class="number">2</span>)]); |
| |
| <span class="kw">let </span>a = [(<span class="number">1</span>, <span class="number">2</span>), (<span class="number">1</span>, <span class="number">3</span>), (<span class="number">1</span>, <span class="number">4</span>), (<span class="number">1</span>, <span class="number">5</span>)]; |
| <span class="macro">assert_eq!</span>(a.iter().min_set_by_key(|&&(k, <span class="kw">_</span>)| k), <span class="macro">vec!</span>[<span class="kw-2">&</span>(<span class="number">1</span>, <span class="number">2</span>), <span class="kw-2">&</span>(<span class="number">1</span>, <span class="number">3</span>), <span class="kw-2">&</span>(<span class="number">1</span>, <span class="number">4</span>), <span class="kw-2">&</span>(<span class="number">1</span>, <span class="number">5</span>)]);</code></pre></div> |
| <p>The elements can be floats but no particular result is guaranteed |
| if an element is NaN.</p> |
| </div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.max_set" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#3021-3025">source</a><h4 class="code-header">fn <a href="#method.max_set" class="fnname">max_set</a>(self) -> Vec<Self::Item><span class="where fmt-newline">where<br> Self: Sized,<br> Self::Item: Ord,</span></h4></section></summary><div class="docblock"><p>Return all maximum elements of an iterator.</p> |
| <h5 id="examples-5"><a href="#examples-5">Examples</a></h5> |
| <div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>itertools::Itertools; |
| |
| <span class="kw">let </span>a: [i32; <span class="number">0</span>] = []; |
| <span class="macro">assert_eq!</span>(a.iter().max_set(), Vec::<<span class="kw-2">&</span>i32>::new()); |
| |
| <span class="kw">let </span>a = [<span class="number">1</span>]; |
| <span class="macro">assert_eq!</span>(a.iter().max_set(), <span class="macro">vec!</span>[<span class="kw-2">&</span><span class="number">1</span>]); |
| |
| <span class="kw">let </span>a = [<span class="number">1</span>, <span class="number">2</span>, <span class="number">3</span>, <span class="number">4</span>, <span class="number">5</span>]; |
| <span class="macro">assert_eq!</span>(a.iter().max_set(), <span class="macro">vec!</span>[<span class="kw-2">&</span><span class="number">5</span>]); |
| |
| <span class="kw">let </span>a = [<span class="number">1</span>, <span class="number">1</span>, <span class="number">1</span>, <span class="number">1</span>]; |
| <span class="macro">assert_eq!</span>(a.iter().max_set(), <span class="macro">vec!</span>[<span class="kw-2">&</span><span class="number">1</span>, <span class="kw-2">&</span><span class="number">1</span>, <span class="kw-2">&</span><span class="number">1</span>, <span class="kw-2">&</span><span class="number">1</span>]);</code></pre></div> |
| <p>The elements can be floats but no particular result is guaranteed |
| if an element is NaN.</p> |
| </div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.max_set_by" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#3052-3060">source</a><h4 class="code-header">fn <a href="#method.max_set_by" class="fnname">max_set_by</a><F>(self, compare: F) -> Vec<Self::Item><span class="where fmt-newline">where<br> Self: Sized,<br> F: FnMut(&Self::Item, &Self::Item) -> Ordering,</span></h4></section></summary><div class="docblock"><p>Return all maximum elements of an iterator, as determined by |
| the specified function.</p> |
| <h5 id="examples-6"><a href="#examples-6">Examples</a></h5> |
| <div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>itertools::Itertools; |
| |
| <span class="kw">let </span>a: [(i32, i32); <span class="number">0</span>] = []; |
| <span class="macro">assert_eq!</span>(a.iter().max_set_by(|<span class="kw">_</span>, <span class="kw">_</span>| Ordering::Equal), Vec::<<span class="kw-2">&</span>(i32, i32)>::new()); |
| |
| <span class="kw">let </span>a = [(<span class="number">1</span>, <span class="number">2</span>)]; |
| <span class="macro">assert_eq!</span>(a.iter().max_set_by(|&&(k1,<span class="kw">_</span>), &&(k2, <span class="kw">_</span>)| k1.cmp(<span class="kw-2">&</span>k2)), <span class="macro">vec!</span>[<span class="kw-2">&</span>(<span class="number">1</span>, <span class="number">2</span>)]); |
| |
| <span class="kw">let </span>a = [(<span class="number">1</span>, <span class="number">2</span>), (<span class="number">2</span>, <span class="number">2</span>), (<span class="number">3</span>, <span class="number">9</span>), (<span class="number">4</span>, <span class="number">8</span>), (<span class="number">5</span>, <span class="number">9</span>)]; |
| <span class="macro">assert_eq!</span>(a.iter().max_set_by(|&&(<span class="kw">_</span>,k1), &&(<span class="kw">_</span>,k2)| k1.cmp(<span class="kw-2">&</span>k2)), <span class="macro">vec!</span>[<span class="kw-2">&</span>(<span class="number">3</span>, <span class="number">9</span>), <span class="kw-2">&</span>(<span class="number">5</span>, <span class="number">9</span>)]); |
| |
| <span class="kw">let </span>a = [(<span class="number">1</span>, <span class="number">2</span>), (<span class="number">1</span>, <span class="number">3</span>), (<span class="number">1</span>, <span class="number">4</span>), (<span class="number">1</span>, <span class="number">5</span>)]; |
| <span class="macro">assert_eq!</span>(a.iter().max_set_by(|&&(k1,<span class="kw">_</span>), &&(k2, <span class="kw">_</span>)| k1.cmp(<span class="kw-2">&</span>k2)), <span class="macro">vec!</span>[<span class="kw-2">&</span>(<span class="number">1</span>, <span class="number">2</span>), <span class="kw-2">&</span>(<span class="number">1</span>, <span class="number">3</span>), <span class="kw-2">&</span>(<span class="number">1</span>, <span class="number">4</span>), <span class="kw-2">&</span>(<span class="number">1</span>, <span class="number">5</span>)]);</code></pre></div> |
| <p>The elements can be floats but no particular result is guaranteed |
| if an element is NaN.</p> |
| </div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.max_set_by_key" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#3086-3090">source</a><h4 class="code-header">fn <a href="#method.max_set_by_key" class="fnname">max_set_by_key</a><K, F>(self, key: F) -> Vec<Self::Item><span class="where fmt-newline">where<br> Self: Sized,<br> K: Ord,<br> F: FnMut(&Self::Item) -> K,</span></h4></section></summary><div class="docblock"><p>Return all minimum elements of an iterator, as determined by |
| the specified function.</p> |
| <h5 id="examples-7"><a href="#examples-7">Examples</a></h5> |
| <div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>itertools::Itertools; |
| |
| <span class="kw">let </span>a: [(i32, i32); <span class="number">0</span>] = []; |
| <span class="macro">assert_eq!</span>(a.iter().max_set_by_key(|<span class="kw">_</span>| ()), Vec::<<span class="kw-2">&</span>(i32, i32)>::new()); |
| |
| <span class="kw">let </span>a = [(<span class="number">1</span>, <span class="number">2</span>)]; |
| <span class="macro">assert_eq!</span>(a.iter().max_set_by_key(|&&(k,<span class="kw">_</span>)| k), <span class="macro">vec!</span>[<span class="kw-2">&</span>(<span class="number">1</span>, <span class="number">2</span>)]); |
| |
| <span class="kw">let </span>a = [(<span class="number">1</span>, <span class="number">2</span>), (<span class="number">2</span>, <span class="number">2</span>), (<span class="number">3</span>, <span class="number">9</span>), (<span class="number">4</span>, <span class="number">8</span>), (<span class="number">5</span>, <span class="number">9</span>)]; |
| <span class="macro">assert_eq!</span>(a.iter().max_set_by_key(|&&(<span class="kw">_</span>, k)| k), <span class="macro">vec!</span>[<span class="kw-2">&</span>(<span class="number">3</span>, <span class="number">9</span>), <span class="kw-2">&</span>(<span class="number">5</span>, <span class="number">9</span>)]); |
| |
| <span class="kw">let </span>a = [(<span class="number">1</span>, <span class="number">2</span>), (<span class="number">1</span>, <span class="number">3</span>), (<span class="number">1</span>, <span class="number">4</span>), (<span class="number">1</span>, <span class="number">5</span>)]; |
| <span class="macro">assert_eq!</span>(a.iter().max_set_by_key(|&&(k, <span class="kw">_</span>)| k), <span class="macro">vec!</span>[<span class="kw-2">&</span>(<span class="number">1</span>, <span class="number">2</span>), <span class="kw-2">&</span>(<span class="number">1</span>, <span class="number">3</span>), <span class="kw-2">&</span>(<span class="number">1</span>, <span class="number">4</span>), <span class="kw-2">&</span>(<span class="number">1</span>, <span class="number">5</span>)]);</code></pre></div> |
| <p>The elements can be floats but no particular result is guaranteed |
| if an element is NaN.</p> |
| </div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.minmax" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#3127-3131">source</a><h4 class="code-header">fn <a href="#method.minmax" class="fnname">minmax</a>(self) -> <a class="enum" href="enum.MinMaxResult.html" title="enum itertools::MinMaxResult">MinMaxResult</a><Self::Item><span class="where fmt-newline">where<br> Self: Sized,<br> Self::Item: PartialOrd,</span></h4></section></summary><div class="docblock"><p>Return the minimum and maximum elements in the iterator.</p> |
| <p>The return type <code>MinMaxResult</code> is an enum of three variants:</p> |
| <ul> |
| <li><code>NoElements</code> if the iterator is empty.</li> |
| <li><code>OneElement(x)</code> if the iterator has exactly one element.</li> |
| <li><code>MinMax(x, y)</code> is returned otherwise, where <code>x <= y</code>. Two |
| values are equal if and only if there is more than one |
| element in the iterator and all elements are equal.</li> |
| </ul> |
| <p>On an iterator of length <code>n</code>, <code>minmax</code> does <code>1.5 * n</code> comparisons, |
| and so is faster than calling <code>min</code> and <code>max</code> separately which does |
| <code>2 * n</code> comparisons.</p> |
| <h5 id="examples-8"><a href="#examples-8">Examples</a></h5> |
| <div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>itertools::Itertools; |
| <span class="kw">use </span>itertools::MinMaxResult::{NoElements, OneElement, MinMax}; |
| |
| <span class="kw">let </span>a: [i32; <span class="number">0</span>] = []; |
| <span class="macro">assert_eq!</span>(a.iter().minmax(), NoElements); |
| |
| <span class="kw">let </span>a = [<span class="number">1</span>]; |
| <span class="macro">assert_eq!</span>(a.iter().minmax(), OneElement(<span class="kw-2">&</span><span class="number">1</span>)); |
| |
| <span class="kw">let </span>a = [<span class="number">1</span>, <span class="number">2</span>, <span class="number">3</span>, <span class="number">4</span>, <span class="number">5</span>]; |
| <span class="macro">assert_eq!</span>(a.iter().minmax(), MinMax(<span class="kw-2">&</span><span class="number">1</span>, <span class="kw-2">&</span><span class="number">5</span>)); |
| |
| <span class="kw">let </span>a = [<span class="number">1</span>, <span class="number">1</span>, <span class="number">1</span>, <span class="number">1</span>]; |
| <span class="macro">assert_eq!</span>(a.iter().minmax(), MinMax(<span class="kw-2">&</span><span class="number">1</span>, <span class="kw-2">&</span><span class="number">1</span>));</code></pre></div> |
| <p>The elements can be floats but no particular result is guaranteed |
| if an element is NaN.</p> |
| </div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.minmax_by_key" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#3144-3148">source</a><h4 class="code-header">fn <a href="#method.minmax_by_key" class="fnname">minmax_by_key</a><K, F>(self, key: F) -> <a class="enum" href="enum.MinMaxResult.html" title="enum itertools::MinMaxResult">MinMaxResult</a><Self::Item><span class="where fmt-newline">where<br> Self: Sized,<br> K: PartialOrd,<br> F: FnMut(&Self::Item) -> K,</span></h4></section></summary><div class="docblock"><p>Return the minimum and maximum element of an iterator, as determined by |
| the specified function.</p> |
| <p>The return value is a variant of <a href="enum.MinMaxResult.html" title="MinMaxResult"><code>MinMaxResult</code></a> like for <a href="trait.Itertools.html#method.minmax"><code>.minmax()</code></a>.</p> |
| <p>For the minimum, the first minimal element is returned. For the maximum, |
| the last maximal element wins. This matches the behavior of the standard |
| [<code>Iterator::min</code>] and [<code>Iterator::max</code>] methods.</p> |
| <p>The keys can be floats but no particular result is guaranteed |
| if a key is NaN.</p> |
| </div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.minmax_by" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#3158-3166">source</a><h4 class="code-header">fn <a href="#method.minmax_by" class="fnname">minmax_by</a><F>(self, compare: F) -> <a class="enum" href="enum.MinMaxResult.html" title="enum itertools::MinMaxResult">MinMaxResult</a><Self::Item><span class="where fmt-newline">where<br> Self: Sized,<br> F: FnMut(&Self::Item, &Self::Item) -> Ordering,</span></h4></section></summary><div class="docblock"><p>Return the minimum and maximum element of an iterator, as determined by |
| the specified comparison function.</p> |
| <p>The return value is a variant of <a href="enum.MinMaxResult.html" title="MinMaxResult"><code>MinMaxResult</code></a> like for <a href="trait.Itertools.html#method.minmax"><code>.minmax()</code></a>.</p> |
| <p>For the minimum, the first minimal element is returned. For the maximum, |
| the last maximal element wins. This matches the behavior of the standard |
| [<code>Iterator::min</code>] and [<code>Iterator::max</code>] methods.</p> |
| </div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.position_max" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#3187-3193">source</a><h4 class="code-header">fn <a href="#method.position_max" class="fnname">position_max</a>(self) -> Option<usize><span class="where fmt-newline">where<br> Self: Sized,<br> Self::Item: Ord,</span></h4></section></summary><div class="docblock"><p>Return the position of the maximum element in the iterator.</p> |
| <p>If several elements are equally maximum, the position of the |
| last of them is returned.</p> |
| <h5 id="examples-9"><a href="#examples-9">Examples</a></h5> |
| <div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>itertools::Itertools; |
| |
| <span class="kw">let </span>a: [i32; <span class="number">0</span>] = []; |
| <span class="macro">assert_eq!</span>(a.iter().position_max(), <span class="prelude-val">None</span>); |
| |
| <span class="kw">let </span>a = [-<span class="number">3</span>, <span class="number">0</span>, <span class="number">1</span>, <span class="number">5</span>, -<span class="number">10</span>]; |
| <span class="macro">assert_eq!</span>(a.iter().position_max(), <span class="prelude-val">Some</span>(<span class="number">3</span>)); |
| |
| <span class="kw">let </span>a = [<span class="number">1</span>, <span class="number">1</span>, -<span class="number">1</span>, -<span class="number">1</span>]; |
| <span class="macro">assert_eq!</span>(a.iter().position_max(), <span class="prelude-val">Some</span>(<span class="number">1</span>));</code></pre></div> |
| </div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.position_max_by_key" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#3215-3221">source</a><h4 class="code-header">fn <a href="#method.position_max_by_key" class="fnname">position_max_by_key</a><K, F>(self, key: F) -> Option<usize><span class="where fmt-newline">where<br> Self: Sized,<br> K: Ord,<br> F: FnMut(&Self::Item) -> K,</span></h4></section></summary><div class="docblock"><p>Return the position of the maximum element in the iterator, as |
| determined by the specified function.</p> |
| <p>If several elements are equally maximum, the position of the |
| last of them is returned.</p> |
| <h5 id="examples-10"><a href="#examples-10">Examples</a></h5> |
| <div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>itertools::Itertools; |
| |
| <span class="kw">let </span>a: [i32; <span class="number">0</span>] = []; |
| <span class="macro">assert_eq!</span>(a.iter().position_max_by_key(|x| x.abs()), <span class="prelude-val">None</span>); |
| |
| <span class="kw">let </span>a = [-<span class="number">3_i32</span>, <span class="number">0</span>, <span class="number">1</span>, <span class="number">5</span>, -<span class="number">10</span>]; |
| <span class="macro">assert_eq!</span>(a.iter().position_max_by_key(|x| x.abs()), <span class="prelude-val">Some</span>(<span class="number">4</span>)); |
| |
| <span class="kw">let </span>a = [<span class="number">1_i32</span>, <span class="number">1</span>, -<span class="number">1</span>, -<span class="number">1</span>]; |
| <span class="macro">assert_eq!</span>(a.iter().position_max_by_key(|x| x.abs()), <span class="prelude-val">Some</span>(<span class="number">3</span>));</code></pre></div> |
| </div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.position_max_by" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#3243-3249">source</a><h4 class="code-header">fn <a href="#method.position_max_by" class="fnname">position_max_by</a><F>(self, compare: F) -> Option<usize><span class="where fmt-newline">where<br> Self: Sized,<br> F: FnMut(&Self::Item, &Self::Item) -> Ordering,</span></h4></section></summary><div class="docblock"><p>Return the position of the maximum element in the iterator, as |
| determined by the specified comparison function.</p> |
| <p>If several elements are equally maximum, the position of the |
| last of them is returned.</p> |
| <h5 id="examples-11"><a href="#examples-11">Examples</a></h5> |
| <div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>itertools::Itertools; |
| |
| <span class="kw">let </span>a: [i32; <span class="number">0</span>] = []; |
| <span class="macro">assert_eq!</span>(a.iter().position_max_by(|x, y| x.cmp(y)), <span class="prelude-val">None</span>); |
| |
| <span class="kw">let </span>a = [-<span class="number">3_i32</span>, <span class="number">0</span>, <span class="number">1</span>, <span class="number">5</span>, -<span class="number">10</span>]; |
| <span class="macro">assert_eq!</span>(a.iter().position_max_by(|x, y| x.cmp(y)), <span class="prelude-val">Some</span>(<span class="number">3</span>)); |
| |
| <span class="kw">let </span>a = [<span class="number">1_i32</span>, <span class="number">1</span>, -<span class="number">1</span>, -<span class="number">1</span>]; |
| <span class="macro">assert_eq!</span>(a.iter().position_max_by(|x, y| x.cmp(y)), <span class="prelude-val">Some</span>(<span class="number">1</span>));</code></pre></div> |
| </div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.position_min" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#3270-3276">source</a><h4 class="code-header">fn <a href="#method.position_min" class="fnname">position_min</a>(self) -> Option<usize><span class="where fmt-newline">where<br> Self: Sized,<br> Self::Item: Ord,</span></h4></section></summary><div class="docblock"><p>Return the position of the minimum element in the iterator.</p> |
| <p>If several elements are equally minimum, the position of the |
| first of them is returned.</p> |
| <h5 id="examples-12"><a href="#examples-12">Examples</a></h5> |
| <div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>itertools::Itertools; |
| |
| <span class="kw">let </span>a: [i32; <span class="number">0</span>] = []; |
| <span class="macro">assert_eq!</span>(a.iter().position_min(), <span class="prelude-val">None</span>); |
| |
| <span class="kw">let </span>a = [-<span class="number">3</span>, <span class="number">0</span>, <span class="number">1</span>, <span class="number">5</span>, -<span class="number">10</span>]; |
| <span class="macro">assert_eq!</span>(a.iter().position_min(), <span class="prelude-val">Some</span>(<span class="number">4</span>)); |
| |
| <span class="kw">let </span>a = [<span class="number">1</span>, <span class="number">1</span>, -<span class="number">1</span>, -<span class="number">1</span>]; |
| <span class="macro">assert_eq!</span>(a.iter().position_min(), <span class="prelude-val">Some</span>(<span class="number">2</span>));</code></pre></div> |
| </div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.position_min_by_key" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#3298-3304">source</a><h4 class="code-header">fn <a href="#method.position_min_by_key" class="fnname">position_min_by_key</a><K, F>(self, key: F) -> Option<usize><span class="where fmt-newline">where<br> Self: Sized,<br> K: Ord,<br> F: FnMut(&Self::Item) -> K,</span></h4></section></summary><div class="docblock"><p>Return the position of the minimum element in the iterator, as |
| determined by the specified function.</p> |
| <p>If several elements are equally minimum, the position of the |
| first of them is returned.</p> |
| <h5 id="examples-13"><a href="#examples-13">Examples</a></h5> |
| <div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>itertools::Itertools; |
| |
| <span class="kw">let </span>a: [i32; <span class="number">0</span>] = []; |
| <span class="macro">assert_eq!</span>(a.iter().position_min_by_key(|x| x.abs()), <span class="prelude-val">None</span>); |
| |
| <span class="kw">let </span>a = [-<span class="number">3_i32</span>, <span class="number">0</span>, <span class="number">1</span>, <span class="number">5</span>, -<span class="number">10</span>]; |
| <span class="macro">assert_eq!</span>(a.iter().position_min_by_key(|x| x.abs()), <span class="prelude-val">Some</span>(<span class="number">1</span>)); |
| |
| <span class="kw">let </span>a = [<span class="number">1_i32</span>, <span class="number">1</span>, -<span class="number">1</span>, -<span class="number">1</span>]; |
| <span class="macro">assert_eq!</span>(a.iter().position_min_by_key(|x| x.abs()), <span class="prelude-val">Some</span>(<span class="number">0</span>));</code></pre></div> |
| </div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.position_min_by" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#3326-3332">source</a><h4 class="code-header">fn <a href="#method.position_min_by" class="fnname">position_min_by</a><F>(self, compare: F) -> Option<usize><span class="where fmt-newline">where<br> Self: Sized,<br> F: FnMut(&Self::Item, &Self::Item) -> Ordering,</span></h4></section></summary><div class="docblock"><p>Return the position of the minimum element in the iterator, as |
| determined by the specified comparison function.</p> |
| <p>If several elements are equally minimum, the position of the |
| first of them is returned.</p> |
| <h5 id="examples-14"><a href="#examples-14">Examples</a></h5> |
| <div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>itertools::Itertools; |
| |
| <span class="kw">let </span>a: [i32; <span class="number">0</span>] = []; |
| <span class="macro">assert_eq!</span>(a.iter().position_min_by(|x, y| x.cmp(y)), <span class="prelude-val">None</span>); |
| |
| <span class="kw">let </span>a = [-<span class="number">3_i32</span>, <span class="number">0</span>, <span class="number">1</span>, <span class="number">5</span>, -<span class="number">10</span>]; |
| <span class="macro">assert_eq!</span>(a.iter().position_min_by(|x, y| x.cmp(y)), <span class="prelude-val">Some</span>(<span class="number">4</span>)); |
| |
| <span class="kw">let </span>a = [<span class="number">1_i32</span>, <span class="number">1</span>, -<span class="number">1</span>, -<span class="number">1</span>]; |
| <span class="macro">assert_eq!</span>(a.iter().position_min_by(|x, y| x.cmp(y)), <span class="prelude-val">Some</span>(<span class="number">2</span>));</code></pre></div> |
| </div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.position_minmax" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#3376-3385">source</a><h4 class="code-header">fn <a href="#method.position_minmax" class="fnname">position_minmax</a>(self) -> <a class="enum" href="enum.MinMaxResult.html" title="enum itertools::MinMaxResult">MinMaxResult</a><usize><span class="where fmt-newline">where<br> Self: Sized,<br> Self::Item: PartialOrd,</span></h4></section></summary><div class="docblock"><p>Return the positions of the minimum and maximum elements in |
| the iterator.</p> |
| <p>The return type <a href="enum.MinMaxResult.html" title="MinMaxResult"><code>MinMaxResult</code></a> is an enum of three variants:</p> |
| <ul> |
| <li><code>NoElements</code> if the iterator is empty.</li> |
| <li><code>OneElement(xpos)</code> if the iterator has exactly one element.</li> |
| <li><code>MinMax(xpos, ypos)</code> is returned otherwise, where the |
| element at <code>xpos</code> ≤ the element at <code>ypos</code>. While the |
| referenced elements themselves may be equal, <code>xpos</code> cannot |
| be equal to <code>ypos</code>.</li> |
| </ul> |
| <p>On an iterator of length <code>n</code>, <code>position_minmax</code> does <code>1.5 * n</code> |
| comparisons, and so is faster than calling <code>position_min</code> and |
| <code>position_max</code> separately which does <code>2 * n</code> comparisons.</p> |
| <p>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.</p> |
| <p>The elements can be floats but no particular result is |
| guaranteed if an element is NaN.</p> |
| <h5 id="examples-15"><a href="#examples-15">Examples</a></h5> |
| <div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>itertools::Itertools; |
| <span class="kw">use </span>itertools::MinMaxResult::{NoElements, OneElement, MinMax}; |
| |
| <span class="kw">let </span>a: [i32; <span class="number">0</span>] = []; |
| <span class="macro">assert_eq!</span>(a.iter().position_minmax(), NoElements); |
| |
| <span class="kw">let </span>a = [<span class="number">10</span>]; |
| <span class="macro">assert_eq!</span>(a.iter().position_minmax(), OneElement(<span class="number">0</span>)); |
| |
| <span class="kw">let </span>a = [-<span class="number">3</span>, <span class="number">0</span>, <span class="number">1</span>, <span class="number">5</span>, -<span class="number">10</span>]; |
| <span class="macro">assert_eq!</span>(a.iter().position_minmax(), MinMax(<span class="number">4</span>, <span class="number">3</span>)); |
| |
| <span class="kw">let </span>a = [<span class="number">1</span>, <span class="number">1</span>, -<span class="number">1</span>, -<span class="number">1</span>]; |
| <span class="macro">assert_eq!</span>(a.iter().position_minmax(), MinMax(<span class="number">2</span>, <span class="number">1</span>));</code></pre></div> |
| </div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.position_minmax_by_key" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#3421-3430">source</a><h4 class="code-header">fn <a href="#method.position_minmax_by_key" class="fnname">position_minmax_by_key</a><K, F>(self, key: F) -> <a class="enum" href="enum.MinMaxResult.html" title="enum itertools::MinMaxResult">MinMaxResult</a><usize><span class="where fmt-newline">where<br> Self: Sized,<br> K: PartialOrd,<br> F: FnMut(&Self::Item) -> K,</span></h4></section></summary><div class="docblock"><p>Return the postions of the minimum and maximum elements of an |
| iterator, as determined by the specified function.</p> |
| <p>The return value is a variant of <a href="enum.MinMaxResult.html" title="MinMaxResult"><code>MinMaxResult</code></a> like for |
| <a href="trait.Itertools.html#method.position_minmax"><code>position_minmax</code></a>.</p> |
| <p>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.</p> |
| <p>The keys can be floats but no particular result is guaranteed |
| if a key is NaN.</p> |
| <h5 id="examples-16"><a href="#examples-16">Examples</a></h5> |
| <div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>itertools::Itertools; |
| <span class="kw">use </span>itertools::MinMaxResult::{NoElements, OneElement, MinMax}; |
| |
| <span class="kw">let </span>a: [i32; <span class="number">0</span>] = []; |
| <span class="macro">assert_eq!</span>(a.iter().position_minmax_by_key(|x| x.abs()), NoElements); |
| |
| <span class="kw">let </span>a = [<span class="number">10_i32</span>]; |
| <span class="macro">assert_eq!</span>(a.iter().position_minmax_by_key(|x| x.abs()), OneElement(<span class="number">0</span>)); |
| |
| <span class="kw">let </span>a = [-<span class="number">3_i32</span>, <span class="number">0</span>, <span class="number">1</span>, <span class="number">5</span>, -<span class="number">10</span>]; |
| <span class="macro">assert_eq!</span>(a.iter().position_minmax_by_key(|x| x.abs()), MinMax(<span class="number">1</span>, <span class="number">4</span>)); |
| |
| <span class="kw">let </span>a = [<span class="number">1_i32</span>, <span class="number">1</span>, -<span class="number">1</span>, -<span class="number">1</span>]; |
| <span class="macro">assert_eq!</span>(a.iter().position_minmax_by_key(|x| x.abs()), MinMax(<span class="number">0</span>, <span class="number">3</span>));</code></pre></div> |
| </div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.position_minmax_by" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#3463-3472">source</a><h4 class="code-header">fn <a href="#method.position_minmax_by" class="fnname">position_minmax_by</a><F>(self, compare: F) -> <a class="enum" href="enum.MinMaxResult.html" title="enum itertools::MinMaxResult">MinMaxResult</a><usize><span class="where fmt-newline">where<br> Self: Sized,<br> F: FnMut(&Self::Item, &Self::Item) -> Ordering,</span></h4></section></summary><div class="docblock"><p>Return the postions of the minimum and maximum elements of an |
| iterator, as determined by the specified comparison function.</p> |
| <p>The return value is a variant of <a href="enum.MinMaxResult.html" title="MinMaxResult"><code>MinMaxResult</code></a> like for |
| <a href="trait.Itertools.html#method.position_minmax"><code>position_minmax</code></a>.</p> |
| <p>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.</p> |
| <h5 id="examples-17"><a href="#examples-17">Examples</a></h5> |
| <div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>itertools::Itertools; |
| <span class="kw">use </span>itertools::MinMaxResult::{NoElements, OneElement, MinMax}; |
| |
| <span class="kw">let </span>a: [i32; <span class="number">0</span>] = []; |
| <span class="macro">assert_eq!</span>(a.iter().position_minmax_by(|x, y| x.cmp(y)), NoElements); |
| |
| <span class="kw">let </span>a = [<span class="number">10_i32</span>]; |
| <span class="macro">assert_eq!</span>(a.iter().position_minmax_by(|x, y| x.cmp(y)), OneElement(<span class="number">0</span>)); |
| |
| <span class="kw">let </span>a = [-<span class="number">3_i32</span>, <span class="number">0</span>, <span class="number">1</span>, <span class="number">5</span>, -<span class="number">10</span>]; |
| <span class="macro">assert_eq!</span>(a.iter().position_minmax_by(|x, y| x.cmp(y)), MinMax(<span class="number">4</span>, <span class="number">3</span>)); |
| |
| <span class="kw">let </span>a = [<span class="number">1_i32</span>, <span class="number">1</span>, -<span class="number">1</span>, -<span class="number">1</span>]; |
| <span class="macro">assert_eq!</span>(a.iter().position_minmax_by(|x, y| x.cmp(y)), MinMax(<span class="number">2</span>, <span class="number">1</span>));</code></pre></div> |
| </div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.exactly_one" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#3491-3508">source</a><h4 class="code-header">fn <a href="#method.exactly_one" class="fnname">exactly_one</a>(self) -> Result<Self::Item, <a class="struct" href="structs/struct.ExactlyOneError.html" title="struct itertools::structs::ExactlyOneError">ExactlyOneError</a><Self>><span class="where fmt-newline">where<br> Self: Sized,</span></h4></section></summary><div class="docblock"><p>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.</p> |
| <p>This provides an additional layer of validation over just calling <code>Iterator::next()</code>. |
| 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.</p> |
| <h5 id="examples-18"><a href="#examples-18">Examples</a></h5> |
| <div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>itertools::Itertools; |
| |
| <span class="macro">assert_eq!</span>((<span class="number">0</span>..<span class="number">10</span>).filter(|<span class="kw-2">&</span>x| x == <span class="number">2</span>).exactly_one().unwrap(), <span class="number">2</span>); |
| <span class="macro">assert!</span>((<span class="number">0</span>..<span class="number">10</span>).filter(|<span class="kw-2">&</span>x| x > <span class="number">1 </span>&& x < <span class="number">4</span>).exactly_one().unwrap_err().eq(<span class="number">2</span>..<span class="number">4</span>)); |
| <span class="macro">assert!</span>((<span class="number">0</span>..<span class="number">10</span>).filter(|<span class="kw-2">&</span>x| x > <span class="number">1 </span>&& x < <span class="number">5</span>).exactly_one().unwrap_err().eq(<span class="number">2</span>..<span class="number">5</span>)); |
| <span class="macro">assert!</span>((<span class="number">0</span>..<span class="number">10</span>).filter(|<span class="kw-2">&</span><span class="kw">_</span>| <span class="bool-val">false</span>).exactly_one().unwrap_err().eq(<span class="number">0</span>..<span class="number">0</span>));</code></pre></div> |
| </div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.at_most_one" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#3527-3544">source</a><h4 class="code-header">fn <a href="#method.at_most_one" class="fnname">at_most_one</a>(self) -> Result<Option<Self::Item>, <a class="struct" href="structs/struct.ExactlyOneError.html" title="struct itertools::structs::ExactlyOneError">ExactlyOneError</a><Self>><span class="where fmt-newline">where<br> Self: Sized,</span></h4></section></summary><div class="docblock"><p>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.</p> |
| <p>This provides an additional layer of validation over just calling <code>Iterator::next()</code>. |
| 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.</p> |
| <h5 id="examples-19"><a href="#examples-19">Examples</a></h5> |
| <div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>itertools::Itertools; |
| |
| <span class="macro">assert_eq!</span>((<span class="number">0</span>..<span class="number">10</span>).filter(|<span class="kw-2">&</span>x| x == <span class="number">2</span>).at_most_one().unwrap(), <span class="prelude-val">Some</span>(<span class="number">2</span>)); |
| <span class="macro">assert!</span>((<span class="number">0</span>..<span class="number">10</span>).filter(|<span class="kw-2">&</span>x| x > <span class="number">1 </span>&& x < <span class="number">4</span>).at_most_one().unwrap_err().eq(<span class="number">2</span>..<span class="number">4</span>)); |
| <span class="macro">assert!</span>((<span class="number">0</span>..<span class="number">10</span>).filter(|<span class="kw-2">&</span>x| x > <span class="number">1 </span>&& x < <span class="number">5</span>).at_most_one().unwrap_err().eq(<span class="number">2</span>..<span class="number">5</span>)); |
| <span class="macro">assert_eq!</span>((<span class="number">0</span>..<span class="number">10</span>).filter(|<span class="kw-2">&</span><span class="kw">_</span>| <span class="bool-val">false</span>).at_most_one().unwrap(), <span class="prelude-val">None</span>);</code></pre></div> |
| </div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.multipeek" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#3561-3566">source</a><h4 class="code-header">fn <a href="#method.multipeek" class="fnname">multipeek</a>(self) -> <a class="struct" href="structs/struct.MultiPeek.html" title="struct itertools::structs::MultiPeek">MultiPeek</a><Self><span class="notable-traits"><span class="notable-traits-tooltip">ⓘ<span class="notable-traits-tooltiptext"><span class="docblock"><span class="notable">Notable traits for <a class="struct" href="structs/struct.MultiPeek.html" title="struct itertools::structs::MultiPeek">MultiPeek</a><I></span><code class="content"><span class="where fmt-newline">impl<I> Iterator for <a class="struct" href="structs/struct.MultiPeek.html" title="struct itertools::structs::MultiPeek">MultiPeek</a><I><span class="where fmt-newline">where<br> I: Iterator,</span></span><span class="where fmt-newline"> type <a class="associatedtype">Item</a> = I::Item;</span></code></span></span></span></span><span class="where fmt-newline">where<br> Self: Sized,</span></h4></section></summary><div class="docblock"><p>An iterator adaptor that allows the user to peek at multiple <code>.next()</code> |
| values without advancing the base iterator.</p> |
| <h5 id="examples-20"><a href="#examples-20">Examples</a></h5> |
| <div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>itertools::Itertools; |
| |
| <span class="kw">let </span><span class="kw-2">mut </span>iter = (<span class="number">0</span>..<span class="number">10</span>).multipeek(); |
| <span class="macro">assert_eq!</span>(iter.peek(), <span class="prelude-val">Some</span>(<span class="kw-2">&</span><span class="number">0</span>)); |
| <span class="macro">assert_eq!</span>(iter.peek(), <span class="prelude-val">Some</span>(<span class="kw-2">&</span><span class="number">1</span>)); |
| <span class="macro">assert_eq!</span>(iter.peek(), <span class="prelude-val">Some</span>(<span class="kw-2">&</span><span class="number">2</span>)); |
| <span class="macro">assert_eq!</span>(iter.next(), <span class="prelude-val">Some</span>(<span class="number">0</span>)); |
| <span class="macro">assert_eq!</span>(iter.peek(), <span class="prelude-val">Some</span>(<span class="kw-2">&</span><span class="number">1</span>));</code></pre></div> |
| </div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.counts" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#3582-3590">source</a><h4 class="code-header">fn <a href="#method.counts" class="fnname">counts</a>(self) -> HashMap<Self::Item, usize><span class="where fmt-newline">where<br> Self: Sized,<br> Self::Item: Eq + Hash,</span></h4></section></summary><div class="docblock"><p>Collect the items in this iterator and return a <code>HashMap</code> which |
| contains each item that appears in the iterator and the number |
| of times it appears.</p> |
| <h5 id="examples-21"><a href="#examples-21">Examples</a></h5> |
| <div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">let </span>counts = [<span class="number">1</span>, <span class="number">1</span>, <span class="number">1</span>, <span class="number">3</span>, <span class="number">3</span>, <span class="number">5</span>].into_iter().counts(); |
| <span class="macro">assert_eq!</span>(counts[<span class="kw-2">&</span><span class="number">1</span>], <span class="number">3</span>); |
| <span class="macro">assert_eq!</span>(counts[<span class="kw-2">&</span><span class="number">3</span>], <span class="number">2</span>); |
| <span class="macro">assert_eq!</span>(counts[<span class="kw-2">&</span><span class="number">5</span>], <span class="number">1</span>); |
| <span class="macro">assert_eq!</span>(counts.get(<span class="kw-2">&</span><span class="number">0</span>), <span class="prelude-val">None</span>);</code></pre></div> |
| </div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.counts_by" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#3625-3632">source</a><h4 class="code-header">fn <a href="#method.counts_by" class="fnname">counts_by</a><K, F>(self, f: F) -> HashMap<K, usize><span class="where fmt-newline">where<br> Self: Sized,<br> K: Eq + Hash,<br> F: FnMut(Self::Item) -> K,</span></h4></section></summary><div class="docblock"><p>Collect the items in this iterator and return a <code>HashMap</code> which |
| contains each item that appears in the iterator and the number |
| of times it appears, |
| determining identity using a keying function.</p> |
| |
| <div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">struct </span>Character { |
| first_name: <span class="kw-2">&</span><span class="lifetime">'static </span>str, |
| last_name: <span class="kw-2">&</span><span class="lifetime">'static </span>str, |
| } |
| |
| <span class="kw">let </span>characters = |
| <span class="macro">vec!</span>[ |
| Character { first_name: <span class="string">"Amy"</span>, last_name: <span class="string">"Pond" </span>}, |
| Character { first_name: <span class="string">"Amy"</span>, last_name: <span class="string">"Wong" </span>}, |
| Character { first_name: <span class="string">"Amy"</span>, last_name: <span class="string">"Santiago" </span>}, |
| Character { first_name: <span class="string">"James"</span>, last_name: <span class="string">"Bond" </span>}, |
| Character { first_name: <span class="string">"James"</span>, last_name: <span class="string">"Sullivan" </span>}, |
| Character { first_name: <span class="string">"James"</span>, last_name: <span class="string">"Norington" </span>}, |
| Character { first_name: <span class="string">"James"</span>, last_name: <span class="string">"Kirk" </span>}, |
| ]; |
| |
| <span class="kw">let </span>first_name_frequency = |
| characters |
| .into_iter() |
| .counts_by(|c| c.first_name); |
| |
| <span class="macro">assert_eq!</span>(first_name_frequency[<span class="string">"Amy"</span>], <span class="number">3</span>); |
| <span class="macro">assert_eq!</span>(first_name_frequency[<span class="string">"James"</span>], <span class="number">4</span>); |
| <span class="macro">assert_eq!</span>(first_name_frequency.contains_key(<span class="string">"Asha"</span>), <span class="bool-val">false</span>);</code></pre></div> |
| </div></details><details class="rustdoc-toggle method-toggle" open><summary><section id="method.multiunzip" class="method has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#3654-3659">source</a><h4 class="code-header">fn <a href="#method.multiunzip" class="fnname">multiunzip</a><FromI>(self) -> FromI<span class="where fmt-newline">where<br> Self: Sized + <a class="trait" href="trait.MultiUnzip.html" title="trait itertools::MultiUnzip">MultiUnzip</a><FromI>,</span></h4></section></summary><div class="docblock"><p>Converts an iterator of tuples into a tuple of containers.</p> |
| <p><code>unzip()</code> consumes an entire iterator of n-ary tuples, producing <code>n</code> collections, one for each |
| column.</p> |
| <p>This function is, in some sense, the opposite of <a href="fn.multizip.html" title="multizip"><code>multizip</code></a>.</p> |
| |
| <div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>itertools::Itertools; |
| |
| <span class="kw">let </span>inputs = <span class="macro">vec!</span>[(<span class="number">1</span>, <span class="number">2</span>, <span class="number">3</span>), (<span class="number">4</span>, <span class="number">5</span>, <span class="number">6</span>), (<span class="number">7</span>, <span class="number">8</span>, <span class="number">9</span>)]; |
| |
| <span class="kw">let </span>(a, b, c): (Vec<<span class="kw">_</span>>, Vec<<span class="kw">_</span>>, Vec<<span class="kw">_</span>>) = inputs |
| .into_iter() |
| .multiunzip(); |
| |
| <span class="macro">assert_eq!</span>(a, <span class="macro">vec!</span>[<span class="number">1</span>, <span class="number">4</span>, <span class="number">7</span>]); |
| <span class="macro">assert_eq!</span>(b, <span class="macro">vec!</span>[<span class="number">2</span>, <span class="number">5</span>, <span class="number">8</span>]); |
| <span class="macro">assert_eq!</span>(c, <span class="macro">vec!</span>[<span class="number">3</span>, <span class="number">6</span>, <span class="number">9</span>]);</code></pre></div> |
| </div></details></div><h2 id="implementors" class="small-section-header">Implementors<a href="#implementors" class="anchor"></a></h2><div id="implementors-list"><section id="impl-Itertools-for-T" class="impl has-srclink"><a class="srclink rightside" href="../src/itertools/lib.rs.html#3662">source</a><a href="#impl-Itertools-for-T" class="anchor"></a><h3 class="code-header">impl<T: ?Sized> <a class="trait" href="trait.Itertools.html" title="trait itertools::Itertools">Itertools</a> for T<span class="where fmt-newline">where<br> T: Iterator,</span></h3></section></div><script src="../implementors/itertools/trait.Itertools.js" async></script></section></div></main><div id="rustdoc-vars" data-root-path="../" data-current-crate="itertools" data-themes="ayu,dark,light" data-resource-suffix="" data-rustdoc-version="1.66.0-nightly (5c8bff74b 2022-10-21)" ></div></body></html> |
