]>
git.proxmox.com Git - rustc.git/blob - vendor/itertools-0.8.2/src/free.rs
1 //! Free functions that create iterator adaptors or call iterator methods.
3 //! The benefit of free functions is that they accept any `IntoIterator` as
4 //! argument, so the resulting code may be easier to read.
6 #[cfg(feature = "use_std")]
8 use std
::iter
::{self, Zip}
;
9 #[cfg(feature = "use_std")]
10 type VecIntoIter
<T
> = ::std
::vec
::IntoIter
<T
>;
12 #[cfg(feature = "use_std")]
20 #[cfg(feature = "use_std")]
21 pub use put_back_n_impl
::put_back_n
;
22 #[cfg(feature = "use_std")]
23 pub use multipeek_impl
::multipeek
;
24 #[cfg(feature = "use_std")]
25 pub use kmerge_impl
::kmerge
;
26 pub use zip_eq_impl
::zip_eq
;
27 pub use merge_join
::merge_join_by
;
28 #[cfg(feature = "use_std")]
29 pub use rciter_impl
::rciter
;
31 /// Iterate `iterable` with a running index.
33 /// `IntoIterator` enabled version of `.enumerate()`.
36 /// use itertools::enumerate;
38 /// for (i, elt) in enumerate(&[1, 2, 3]) {
42 pub fn enumerate
<I
>(iterable
: I
) -> iter
::Enumerate
<I
::IntoIter
>
45 iterable
.into_iter().enumerate()
48 /// Iterate `iterable` in reverse.
50 /// `IntoIterator` enabled version of `.rev()`.
53 /// use itertools::rev;
55 /// for elt in rev(&[1, 2, 3]) {
59 pub fn rev
<I
>(iterable
: I
) -> iter
::Rev
<I
::IntoIter
>
60 where I
: IntoIterator
,
61 I
::IntoIter
: DoubleEndedIterator
63 iterable
.into_iter().rev()
66 /// Iterate `i` and `j` in lock step.
68 /// `IntoIterator` enabled version of `i.zip(j)`.
71 /// use itertools::zip;
73 /// let data = [1, 2, 3, 4, 5];
74 /// for (a, b) in zip(&data, &data[1..]) {
78 pub fn zip
<I
, J
>(i
: I
, j
: J
) -> Zip
<I
::IntoIter
, J
::IntoIter
>
79 where I
: IntoIterator
,
85 /// Create an iterator that first iterates `i` and then `j`.
87 /// `IntoIterator` enabled version of `i.chain(j)`.
90 /// use itertools::chain;
92 /// for elt in chain(&[1, 2, 3], &[4]) {
96 pub fn chain
<I
, J
>(i
: I
, j
: J
) -> iter
::Chain
<<I
as IntoIterator
>::IntoIter
, <J
as IntoIterator
>::IntoIter
>
97 where I
: IntoIterator
,
98 J
: IntoIterator
<Item
= I
::Item
>
100 i
.into_iter().chain(j
)
103 /// Create an iterator that clones each element from &T to T
105 /// `IntoIterator` enabled version of `i.cloned()`.
108 /// use itertools::cloned;
110 /// assert_eq!(cloned(b"abc").next(), Some(b'a'));
112 pub fn cloned
<'a
, I
, T
: 'a
>(iterable
: I
) -> iter
::Cloned
<I
::IntoIter
>
113 where I
: IntoIterator
<Item
=&'a T
>,
116 iterable
.into_iter().cloned()
119 /// Perform a fold operation over the iterable.
121 /// `IntoIterator` enabled version of `i.fold(init, f)`
124 /// use itertools::fold;
126 /// assert_eq!(fold(&[1., 2., 3.], 0., |a, &b| f32::max(a, b)), 3.);
128 pub fn fold
<I
, B
, F
>(iterable
: I
, init
: B
, f
: F
) -> B
129 where I
: IntoIterator
,
130 F
: FnMut(B
, I
::Item
) -> B
132 iterable
.into_iter().fold(init
, f
)
135 /// Test whether the predicate holds for all elements in the iterable.
137 /// `IntoIterator` enabled version of `i.all(f)`
140 /// use itertools::all;
142 /// assert!(all(&[1, 2, 3], |elt| *elt > 0));
144 pub fn all
<I
, F
>(iterable
: I
, f
: F
) -> bool
145 where I
: IntoIterator
,
146 F
: FnMut(I
::Item
) -> bool
148 iterable
.into_iter().all(f
)
151 /// Test whether the predicate holds for any elements in the iterable.
153 /// `IntoIterator` enabled version of `i.any(f)`
156 /// use itertools::any;
158 /// assert!(any(&[0, -1, 2], |elt| *elt > 0));
160 pub fn any
<I
, F
>(iterable
: I
, f
: F
) -> bool
161 where I
: IntoIterator
,
162 F
: FnMut(I
::Item
) -> bool
164 iterable
.into_iter().any(f
)
167 /// Return the maximum value of the iterable.
169 /// `IntoIterator` enabled version of `i.max()`.
172 /// use itertools::max;
174 /// assert_eq!(max(0..10), Some(9));
176 pub fn max
<I
>(iterable
: I
) -> Option
<I
::Item
>
177 where I
: IntoIterator
,
180 iterable
.into_iter().max()
183 /// Return the minimum value of the iterable.
185 /// `IntoIterator` enabled version of `i.min()`.
188 /// use itertools::min;
190 /// assert_eq!(min(0..10), Some(0));
192 pub fn min
<I
>(iterable
: I
) -> Option
<I
::Item
>
193 where I
: IntoIterator
,
196 iterable
.into_iter().min()
200 /// Combine all iterator elements into one String, seperated by `sep`.
202 /// `IntoIterator` enabled version of `iterable.join(sep)`.
205 /// use itertools::join;
207 /// assert_eq!(join(&[1, 2, 3], ", "), "1, 2, 3");
209 #[cfg(feature = "use_std")]
210 pub fn join
<I
>(iterable
: I
, sep
: &str) -> String
211 where I
: IntoIterator
,
214 iterable
.into_iter().join(sep
)
217 /// Sort all iterator elements into a new iterator in ascending order.
219 /// `IntoIterator` enabled version of [`iterable.sorted()`][1].
221 /// [1]: trait.Itertools.html#method.sorted
224 /// use itertools::sorted;
225 /// use itertools::assert_equal;
227 /// assert_equal(sorted("rust".chars()), "rstu".chars());
229 #[cfg(feature = "use_std")]
230 pub fn sorted
<I
>(iterable
: I
) -> VecIntoIter
<I
::Item
>
231 where I
: IntoIterator
,
234 iterable
.into_iter().sorted()