pub struct Walk<'g> { /* private fields */ }
walk
only.Expand description
Iterator over files matching a Glob
in a directory tree.
Walk
is a TreeIterator
and supports FileIterator::filter_tree
.
Implementations§
source§impl<'g> Walk<'g>
impl<'g> Walk<'g>
sourcepub fn into_owned(self) -> Walk<'static> ⓘ
pub fn into_owned(self) -> Walk<'static> ⓘ
Clones any borrowed data into an owning instance.
sourcepub fn for_each_ref(self, f: impl FnMut(Result<WalkEntry<'_>, WalkError>))
pub fn for_each_ref(self, f: impl FnMut(Result<WalkEntry<'_>, WalkError>))
Calls a closure on each matched file or error.
This function is similar to for_each
, but does not clone paths and matched
text and so may be somewhat more efficient. Note that the closure receives
borrowing WalkEntry
s rather than 'static
items.
sourcepub fn not<'t, I>(
self,
patterns: I
) -> Result<impl 'g + FileIterator, BuildError>where
I: IntoIterator,
I::Item: Combine<'t>,
pub fn not<'t, I>( self, patterns: I ) -> Result<impl 'g + FileIterator, BuildError>where I: IntoIterator, I::Item: Combine<'t>,
Filters WalkEntry
s against negated glob expressions.
This function creates an adaptor that discards WalkEntry
s that match any of the given
glob expressions. This allows for broad negations while matching a Glob
against a
directory tree that cannot be achieved using a single glob expression alone.
The adaptor is constructed via FilterTree
and WalkNegation
and therefore does not
read directory trees from the file system when a directory matches an exhaustive glob
expression such as **/private/**
or hidden/<<?>/>*
. This
function should be preferred when filtering WalkEntry
s against Glob
s, since this
avoids potentially large and unnecessary reads.
Errors
Returns an error if any of the inputs fail to build. If the inputs are a compiled
Pattern
type such as Glob
, then this only occurs if the compiled program is too
large.
Examples
Because glob expressions do not support general negations, it is sometimes impossible to
express patterns that deny particular text. In such cases, not
can be used to apply
additional patterns as a filter.
use wax::Glob;
// Find image files, but not if they are beneath a directory with a name that suggests that
// they are private.
let glob = Glob::new("**/*.(?i){jpg,jpeg,png}").unwrap();
for entry in glob.walk(".").not(["**/(?i)<.:0,1>private/**"]).unwrap() {
let entry = entry.unwrap();
// ...
}
sourcepub fn root(&self) -> &Path
pub fn root(&self) -> &Path
Gets the root directory of the traversal.
The root directory is determined by joining the directory path in functions like
Glob::walk
with any invariant prefix of the Glob
. When a
Glob
is rooted, the root directory is the same as the invariant prefix.
The depth specified via WalkBehavior
is relative to this path.
Trait Implementations§
source§impl Iterator for Walk<'_>
impl Iterator for Walk<'_>
source§fn next(&mut self) -> Option<Self::Item>
fn next(&mut self) -> Option<Self::Item>
source§fn next_chunk<const N: usize>(
&mut self
) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>where
Self: Sized,
fn next_chunk<const N: usize>( &mut self ) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>where Self: Sized,
iter_next_chunk
)N
values. Read more1.0.0 · source§fn size_hint(&self) -> (usize, Option<usize>)
fn size_hint(&self) -> (usize, Option<usize>)
1.0.0 · source§fn count(self) -> usizewhere
Self: Sized,
fn count(self) -> usizewhere Self: Sized,
1.0.0 · source§fn last(self) -> Option<Self::Item>where
Self: Sized,
fn last(self) -> Option<Self::Item>where Self: Sized,
source§fn advance_by(&mut self, n: usize) -> Result<(), NonZeroUsize>
fn advance_by(&mut self, n: usize) -> Result<(), NonZeroUsize>
iter_advance_by
)n
elements. Read more1.0.0 · source§fn nth(&mut self, n: usize) -> Option<Self::Item>
fn nth(&mut self, n: usize) -> Option<Self::Item>
n
th element of the iterator. Read more1.28.0 · source§fn step_by(self, step: usize) -> StepBy<Self>where
Self: Sized,
fn step_by(self, step: usize) -> StepBy<Self>where Self: Sized,
1.0.0 · source§fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>where
Self: Sized,
U: IntoIterator<Item = Self::Item>,
fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>where Self: Sized, U: IntoIterator<Item = Self::Item>,
1.0.0 · source§fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>where
Self: Sized,
U: IntoIterator,
fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>where Self: Sized, U: IntoIterator,
source§fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>where
Self: Sized,
G: FnMut() -> Self::Item,
fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>where Self: Sized, G: FnMut() -> Self::Item,
iter_intersperse
)separator
between adjacent items of the original iterator. Read more1.0.0 · source§fn map<B, F>(self, f: F) -> Map<Self, F>where
Self: Sized,
F: FnMut(Self::Item) -> B,
fn map<B, F>(self, f: F) -> Map<Self, F>where Self: Sized, F: FnMut(Self::Item) -> B,
1.21.0 · source§fn for_each<F>(self, f: F)where
Self: Sized,
F: FnMut(Self::Item),
fn for_each<F>(self, f: F)where Self: Sized, F: FnMut(Self::Item),
1.0.0 · source§fn filter<P>(self, predicate: P) -> Filter<Self, P>where
Self: Sized,
P: FnMut(&Self::Item) -> bool,
fn filter<P>(self, predicate: P) -> Filter<Self, P>where Self: Sized, P: FnMut(&Self::Item) -> bool,
1.0.0 · source§fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>where
Self: Sized,
F: FnMut(Self::Item) -> Option<B>,
fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>where Self: Sized, F: FnMut(Self::Item) -> Option<B>,
1.0.0 · source§fn enumerate(self) -> Enumerate<Self>where
Self: Sized,
fn enumerate(self) -> Enumerate<Self>where Self: Sized,
1.0.0 · source§fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>where
Self: Sized,
P: FnMut(&Self::Item) -> bool,
fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>where Self: Sized, P: FnMut(&Self::Item) -> bool,
1.0.0 · source§fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>where
Self: Sized,
P: FnMut(&Self::Item) -> bool,
fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>where Self: Sized, P: FnMut(&Self::Item) -> bool,
1.57.0 · source§fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>where
Self: Sized,
P: FnMut(Self::Item) -> Option<B>,
fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>where Self: Sized, P: FnMut(Self::Item) -> Option<B>,
1.0.0 · source§fn skip(self, n: usize) -> Skip<Self>where
Self: Sized,
fn skip(self, n: usize) -> Skip<Self>where Self: Sized,
n
elements. Read more1.0.0 · source§fn take(self, n: usize) -> Take<Self>where
Self: Sized,
fn take(self, n: usize) -> Take<Self>where Self: Sized,
n
elements, or fewer
if the underlying iterator ends sooner. Read more1.0.0 · source§fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>where
Self: Sized,
F: FnMut(&mut St, Self::Item) -> Option<B>,
fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>where Self: Sized, F: FnMut(&mut St, Self::Item) -> Option<B>,
1.0.0 · source§fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>where
Self: Sized,
U: IntoIterator,
F: FnMut(Self::Item) -> U,
fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>where Self: Sized, U: IntoIterator, F: FnMut(Self::Item) -> U,
source§fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>where
Self: Sized,
F: FnMut(&[Self::Item; N]) -> R,
fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>where Self: Sized, F: FnMut(&[Self::Item; N]) -> R,
iter_map_windows
)f
for each contiguous window of size N
over
self
and returns an iterator over the outputs of f
. Like slice::windows()
,
the windows during mapping overlap as well. Read more1.0.0 · source§fn inspect<F>(self, f: F) -> Inspect<Self, F>where
Self: Sized,
F: FnMut(&Self::Item),
fn inspect<F>(self, f: F) -> Inspect<Self, F>where Self: Sized, F: FnMut(&Self::Item),
1.0.0 · source§fn by_ref(&mut self) -> &mut Selfwhere
Self: Sized,
fn by_ref(&mut self) -> &mut Selfwhere Self: Sized,
1.0.0 · source§fn collect<B>(self) -> Bwhere
B: FromIterator<Self::Item>,
Self: Sized,
fn collect<B>(self) -> Bwhere B: FromIterator<Self::Item>, Self: Sized,
source§fn collect_into<E>(self, collection: &mut E) -> &mut Ewhere
E: Extend<Self::Item>,
Self: Sized,
fn collect_into<E>(self, collection: &mut E) -> &mut Ewhere E: Extend<Self::Item>, Self: Sized,
iter_collect_into
)1.0.0 · source§fn partition<B, F>(self, f: F) -> (B, B)where
Self: Sized,
B: Default + Extend<Self::Item>,
F: FnMut(&Self::Item) -> bool,
fn partition<B, F>(self, f: F) -> (B, B)where Self: Sized, B: Default + Extend<Self::Item>, F: FnMut(&Self::Item) -> bool,
source§fn is_partitioned<P>(self, predicate: P) -> boolwhere
Self: Sized,
P: FnMut(Self::Item) -> bool,
fn is_partitioned<P>(self, predicate: P) -> boolwhere Self: Sized, P: FnMut(Self::Item) -> bool,
iter_is_partitioned
)true
precede all those that return false
. Read more1.27.0 · source§fn try_fold<B, F, R>(&mut self, init: B, f: F) -> Rwhere
Self: Sized,
F: FnMut(B, Self::Item) -> R,
R: Try<Output = B>,
fn try_fold<B, F, R>(&mut self, init: B, f: F) -> Rwhere Self: Sized, F: FnMut(B, Self::Item) -> R, R: Try<Output = B>,
1.27.0 · source§fn try_for_each<F, R>(&mut self, f: F) -> Rwhere
Self: Sized,
F: FnMut(Self::Item) -> R,
R: Try<Output = ()>,
fn try_for_each<F, R>(&mut self, f: F) -> Rwhere Self: Sized, F: FnMut(Self::Item) -> R, R: Try<Output = ()>,
1.0.0 · source§fn fold<B, F>(self, init: B, f: F) -> Bwhere
Self: Sized,
F: FnMut(B, Self::Item) -> B,
fn fold<B, F>(self, init: B, f: F) -> Bwhere Self: Sized, F: FnMut(B, Self::Item) -> B,
1.51.0 · source§fn reduce<F>(self, f: F) -> Option<Self::Item>where
Self: Sized,
F: FnMut(Self::Item, Self::Item) -> Self::Item,
fn reduce<F>(self, f: F) -> Option<Self::Item>where Self: Sized, F: FnMut(Self::Item, Self::Item) -> Self::Item,
source§fn try_reduce<F, R>(
&mut self,
f: F
) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryTypewhere
Self: Sized,
F: FnMut(Self::Item, Self::Item) -> R,
R: Try<Output = Self::Item>,
<R as Try>::Residual: Residual<Option<Self::Item>>,
fn try_reduce<F, R>( &mut self, f: F ) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryTypewhere Self: Sized, F: FnMut(Self::Item, Self::Item) -> R, R: Try<Output = Self::Item>, <R as Try>::Residual: Residual<Option<Self::Item>>,
iterator_try_reduce
)1.0.0 · source§fn all<F>(&mut self, f: F) -> boolwhere
Self: Sized,
F: FnMut(Self::Item) -> bool,
fn all<F>(&mut self, f: F) -> boolwhere Self: Sized, F: FnMut(Self::Item) -> bool,
1.0.0 · source§fn any<F>(&mut self, f: F) -> boolwhere
Self: Sized,
F: FnMut(Self::Item) -> bool,
fn any<F>(&mut self, f: F) -> boolwhere Self: Sized, F: FnMut(Self::Item) -> bool,
1.0.0 · source§fn find<P>(&mut self, predicate: P) -> Option<Self::Item>where
Self: Sized,
P: FnMut(&Self::Item) -> bool,
fn find<P>(&mut self, predicate: P) -> Option<Self::Item>where Self: Sized, P: FnMut(&Self::Item) -> bool,
1.30.0 · source§fn find_map<B, F>(&mut self, f: F) -> Option<B>where
Self: Sized,
F: FnMut(Self::Item) -> Option<B>,
fn find_map<B, F>(&mut self, f: F) -> Option<B>where Self: Sized, F: FnMut(Self::Item) -> Option<B>,
source§fn try_find<F, R>(
&mut self,
f: F
) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryTypewhere
Self: Sized,
F: FnMut(&Self::Item) -> R,
R: Try<Output = bool>,
<R as Try>::Residual: Residual<Option<Self::Item>>,
fn try_find<F, R>( &mut self, f: F ) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryTypewhere Self: Sized, F: FnMut(&Self::Item) -> R, R: Try<Output = bool>, <R as Try>::Residual: Residual<Option<Self::Item>>,
try_find
)1.0.0 · source§fn position<P>(&mut self, predicate: P) -> Option<usize>where
Self: Sized,
P: FnMut(Self::Item) -> bool,
fn position<P>(&mut self, predicate: P) -> Option<usize>where Self: Sized, P: FnMut(Self::Item) -> bool,
1.6.0 · source§fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>where
B: Ord,
Self: Sized,
F: FnMut(&Self::Item) -> B,
fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>where B: Ord, Self: Sized, F: FnMut(&Self::Item) -> B,
1.15.0 · source§fn max_by<F>(self, compare: F) -> Option<Self::Item>where
Self: Sized,
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
fn max_by<F>(self, compare: F) -> Option<Self::Item>where Self: Sized, F: FnMut(&Self::Item, &Self::Item) -> Ordering,
1.6.0 · source§fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>where
B: Ord,
Self: Sized,
F: FnMut(&Self::Item) -> B,
fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>where B: Ord, Self: Sized, F: FnMut(&Self::Item) -> B,
1.15.0 · source§fn min_by<F>(self, compare: F) -> Option<Self::Item>where
Self: Sized,
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
fn min_by<F>(self, compare: F) -> Option<Self::Item>where Self: Sized, F: FnMut(&Self::Item, &Self::Item) -> Ordering,
1.0.0 · source§fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)where
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
Self: Sized + Iterator<Item = (A, B)>,
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)where FromA: Default + Extend<A>, FromB: Default + Extend<B>, Self: Sized + Iterator<Item = (A, B)>,
1.36.0 · source§fn copied<'a, T>(self) -> Copied<Self>where
T: 'a + Copy,
Self: Sized + Iterator<Item = &'a T>,
fn copied<'a, T>(self) -> Copied<Self>where T: 'a + Copy, Self: Sized + Iterator<Item = &'a T>,
1.0.0 · source§fn cloned<'a, T>(self) -> Cloned<Self>where
T: 'a + Clone,
Self: Sized + Iterator<Item = &'a T>,
fn cloned<'a, T>(self) -> Cloned<Self>where T: 'a + Clone, Self: Sized + Iterator<Item = &'a T>,
source§fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>where
Self: Sized,
fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>where Self: Sized,
iter_array_chunks
)N
elements of the iterator at a time. Read more1.11.0 · source§fn sum<S>(self) -> Swhere
Self: Sized,
S: Sum<Self::Item>,
fn sum<S>(self) -> Swhere Self: Sized, S: Sum<Self::Item>,
1.11.0 · source§fn product<P>(self) -> Pwhere
Self: Sized,
P: Product<Self::Item>,
fn product<P>(self) -> Pwhere Self: Sized, P: Product<Self::Item>,
source§fn cmp_by<I, F>(self, other: I, cmp: F) -> Orderingwhere
Self: Sized,
I: IntoIterator,
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
fn cmp_by<I, F>(self, other: I, cmp: F) -> Orderingwhere Self: Sized, I: IntoIterator, F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
iter_order_by
)Iterator
with those
of another with respect to the specified comparison function. Read more1.5.0 · source§fn partial_cmp<I>(self, other: I) -> Option<Ordering>where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
Self: Sized,
fn partial_cmp<I>(self, other: I) -> Option<Ordering>where I: IntoIterator, Self::Item: PartialOrd<<I as IntoIterator>::Item>, Self: Sized,
PartialOrd
elements of
this Iterator
with those of another. The comparison works like short-circuit
evaluation, returning a result without comparing the remaining elements.
As soon as an order can be determined, the evaluation stops and a result is returned. Read moresource§fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>where
Self: Sized,
I: IntoIterator,
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>where Self: Sized, I: IntoIterator, F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
iter_order_by
)Iterator
with those
of another with respect to the specified comparison function. Read more1.5.0 · source§fn eq<I>(self, other: I) -> boolwhere
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>,
Self: Sized,
fn eq<I>(self, other: I) -> boolwhere I: IntoIterator, Self::Item: PartialEq<<I as IntoIterator>::Item>, Self: Sized,
source§fn eq_by<I, F>(self, other: I, eq: F) -> boolwhere
Self: Sized,
I: IntoIterator,
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
fn eq_by<I, F>(self, other: I, eq: F) -> boolwhere Self: Sized, I: IntoIterator, F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
iter_order_by
)1.5.0 · source§fn ne<I>(self, other: I) -> boolwhere
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>,
Self: Sized,
fn ne<I>(self, other: I) -> boolwhere I: IntoIterator, Self::Item: PartialEq<<I as IntoIterator>::Item>, Self: Sized,
1.5.0 · source§fn lt<I>(self, other: I) -> boolwhere
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
Self: Sized,
fn lt<I>(self, other: I) -> boolwhere I: IntoIterator, Self::Item: PartialOrd<<I as IntoIterator>::Item>, Self: Sized,
Iterator
are lexicographically
less than those of another. Read more1.5.0 · source§fn le<I>(self, other: I) -> boolwhere
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
Self: Sized,
fn le<I>(self, other: I) -> boolwhere I: IntoIterator, Self::Item: PartialOrd<<I as IntoIterator>::Item>, Self: Sized,
Iterator
are lexicographically
less or equal to those of another. Read more1.5.0 · source§fn gt<I>(self, other: I) -> boolwhere
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
Self: Sized,
fn gt<I>(self, other: I) -> boolwhere I: IntoIterator, Self::Item: PartialOrd<<I as IntoIterator>::Item>, Self: Sized,
Iterator
are lexicographically
greater than those of another. Read more1.5.0 · source§fn ge<I>(self, other: I) -> boolwhere
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
Self: Sized,
fn ge<I>(self, other: I) -> boolwhere I: IntoIterator, Self::Item: PartialOrd<<I as IntoIterator>::Item>, Self: Sized,
Iterator
are lexicographically
greater than or equal to those of another. Read moresource§fn is_sorted_by<F>(self, compare: F) -> boolwhere
Self: Sized,
F: FnMut(&Self::Item, &Self::Item) -> Option<Ordering>,
fn is_sorted_by<F>(self, compare: F) -> boolwhere Self: Sized, F: FnMut(&Self::Item, &Self::Item) -> Option<Ordering>,
is_sorted
)source§fn is_sorted_by_key<F, K>(self, f: F) -> boolwhere
Self: Sized,
F: FnMut(Self::Item) -> K,
K: PartialOrd,
fn is_sorted_by_key<F, K>(self, f: F) -> boolwhere Self: Sized, F: FnMut(Self::Item) -> K, K: PartialOrd,
is_sorted
)Auto Trait Implementations§
impl<'g> !RefUnwindSafe for Walk<'g>
impl<'g> Send for Walk<'g>
impl<'g> Sync for Walk<'g>
impl<'g> Unpin for Walk<'g>
impl<'g> !UnwindSafe for Walk<'g>
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
source§impl<I> FileIterator for Iwhere
I: TreeIterator<Item = Result<WalkEntry<'static>, WalkError>>,
impl<I> FileIterator for Iwhere I: TreeIterator<Item = Result<WalkEntry<'static>, WalkError>>,
source§fn filter_tree<F>(self, f: F) -> FilterTree<I, F> ⓘwhere
F: FnMut(&WalkEntry<'static>) -> Option<FilterTarget>,
fn filter_tree<F>(self, f: F) -> FilterTree<I, F> ⓘwhere F: FnMut(&WalkEntry<'static>) -> Option<FilterTarget>,
walk
only.source§impl<I> IntoIterator for Iwhere
I: Iterator,
impl<I> IntoIterator for Iwhere I: Iterator,
source§impl<I> IteratorExt for Iwhere
I: Iterator,
impl<I> IteratorExt for Iwhere I: Iterator,
source§fn into_non_error_diagnostic<'d>(
self
) -> Result<((), Vec<Box<dyn Diagnostic + 'd>>), Vec1<Box<dyn Diagnostic + 'd>>>where
I: Iterator<Item = Box<dyn Diagnostic + 'd>>,
fn into_non_error_diagnostic<'d>( self ) -> Result<((), Vec<Box<dyn Diagnostic + 'd>>), Vec1<Box<dyn Diagnostic + 'd>>>where I: Iterator<Item = Box<dyn Diagnostic + 'd>>,
Iterator<Item = BoxedDiagnostic<'d>>
into
DiagnosticResult<'d, ()>
. Read moresource§impl<T> Itertools for Twhere
T: Iterator + ?Sized,
impl<T> Itertools for Twhere T: Iterator + ?Sized,
source§fn interleave<J>(
self,
other: J
) -> Interleave<Self, <J as IntoIterator>::IntoIter>where
J: IntoIterator<Item = Self::Item>,
Self: Sized,
fn interleave<J>( self, other: J ) -> Interleave<Self, <J as IntoIterator>::IntoIter>where J: IntoIterator<Item = Self::Item>, Self: Sized,
source§fn interleave_shortest<J>(
self,
other: J
) -> InterleaveShortest<Self, <J as IntoIterator>::IntoIter>where
J: IntoIterator<Item = Self::Item>,
Self: Sized,
fn interleave_shortest<J>( self, other: J ) -> InterleaveShortest<Self, <J as IntoIterator>::IntoIter>where J: IntoIterator<Item = Self::Item>, Self: Sized,
source§fn intersperse(
self,
element: Self::Item
) -> IntersperseWith<Self, IntersperseElementSimple<Self::Item>>where
Self: Sized,
Self::Item: Clone,
fn intersperse( self, element: Self::Item ) -> IntersperseWith<Self, IntersperseElementSimple<Self::Item>>where Self: Sized, Self::Item: Clone,
source§fn intersperse_with<F>(self, element: F) -> IntersperseWith<Self, F>where
Self: Sized,
F: FnMut() -> Self::Item,
fn intersperse_with<F>(self, element: F) -> IntersperseWith<Self, F>where Self: Sized, F: FnMut() -> Self::Item,
source§fn zip_longest<J>(
self,
other: J
) -> ZipLongest<Self, <J as IntoIterator>::IntoIter>where
J: IntoIterator,
Self: Sized,
fn zip_longest<J>( self, other: J ) -> ZipLongest<Self, <J as IntoIterator>::IntoIter>where J: IntoIterator, Self: Sized,
source§fn zip_eq<J>(self, other: J) -> ZipEq<Self, <J as IntoIterator>::IntoIter>where
J: IntoIterator,
Self: Sized,
fn zip_eq<J>(self, other: J) -> ZipEq<Self, <J as IntoIterator>::IntoIter>where J: IntoIterator, Self: Sized,
source§fn batching<B, F>(self, f: F) -> Batching<Self, F>where
F: FnMut(&mut Self) -> Option<B>,
Self: Sized,
fn batching<B, F>(self, f: F) -> Batching<Self, F>where F: FnMut(&mut Self) -> Option<B>, Self: Sized,
source§fn group_by<K, F>(self, key: F) -> GroupBy<K, Self, F>where
Self: Sized,
F: FnMut(&Self::Item) -> K,
K: PartialEq,
fn group_by<K, F>(self, key: F) -> GroupBy<K, Self, F>where Self: Sized, F: FnMut(&Self::Item) -> K, K: PartialEq,
source§fn chunks(self, size: usize) -> IntoChunks<Self>where
Self: Sized,
fn chunks(self, size: usize) -> IntoChunks<Self>where Self: Sized,
source§fn tuple_windows<T>(self) -> TupleWindows<Self, T>where
Self: Sized + Iterator<Item = <T as TupleCollect>::Item>,
T: HomogeneousTuple,
<T as TupleCollect>::Item: Clone,
fn tuple_windows<T>(self) -> TupleWindows<Self, T>where Self: Sized + Iterator<Item = <T as TupleCollect>::Item>, T: HomogeneousTuple, <T as TupleCollect>::Item: Clone,
source§fn circular_tuple_windows<T>(self) -> CircularTupleWindows<Self, T>where
Self: Sized + Clone + Iterator<Item = <T as TupleCollect>::Item> + ExactSizeIterator,
T: TupleCollect + Clone,
<T as TupleCollect>::Item: Clone,
fn circular_tuple_windows<T>(self) -> CircularTupleWindows<Self, T>where Self: Sized + Clone + Iterator<Item = <T as TupleCollect>::Item> + ExactSizeIterator, T: TupleCollect + Clone, <T as TupleCollect>::Item: Clone,
source§fn tuples<T>(self) -> Tuples<Self, T>where
Self: Sized + Iterator<Item = <T as TupleCollect>::Item>,
T: HomogeneousTuple,
fn tuples<T>(self) -> Tuples<Self, T>where Self: Sized + Iterator<Item = <T as TupleCollect>::Item>, T: HomogeneousTuple,
source§fn tee(self) -> (Tee<Self>, Tee<Self>)where
Self: Sized,
Self::Item: Clone,
fn tee(self) -> (Tee<Self>, Tee<Self>)where Self: Sized, Self::Item: Clone,
source§fn step(self, n: usize) -> Step<Self>where
Self: Sized,
fn step(self, n: usize) -> Step<Self>where Self: Sized,
n
elements in the base iterator
for each iteration. Read moresource§fn map_into<R>(self) -> MapSpecialCase<Self, MapSpecialCaseFnInto<R>>where
Self: Sized,
Self::Item: Into<R>,
fn map_into<R>(self) -> MapSpecialCase<Self, MapSpecialCaseFnInto<R>>where Self: Sized, Self::Item: Into<R>,
source§fn map_results<F, T, U, E>(
self,
f: F
) -> MapSpecialCase<Self, MapSpecialCaseFnOk<F>>where
Self: Iterator<Item = Result<T, E>> + Sized,
F: FnMut(T) -> U,
fn map_results<F, T, U, E>( self, f: F ) -> MapSpecialCase<Self, MapSpecialCaseFnOk<F>>where Self: Iterator<Item = Result<T, E>> + Sized, F: FnMut(T) -> U,
.map_ok()
.source§fn map_ok<F, T, U, E>(self, f: F) -> MapSpecialCase<Self, MapSpecialCaseFnOk<F>>where
Self: Iterator<Item = Result<T, E>> + Sized,
F: FnMut(T) -> U,
fn map_ok<F, T, U, E>(self, f: F) -> MapSpecialCase<Self, MapSpecialCaseFnOk<F>>where Self: Iterator<Item = Result<T, E>> + Sized, F: FnMut(T) -> U,
Result::Ok
value. Result::Err
values are
unchanged. Read moresource§fn filter_ok<F, T, E>(self, f: F) -> FilterOk<Self, F>where
Self: Iterator<Item = Result<T, E>> + Sized,
F: FnMut(&T) -> bool,
fn filter_ok<F, T, E>(self, f: F) -> FilterOk<Self, F>where Self: Iterator<Item = Result<T, E>> + Sized, F: FnMut(&T) -> bool,
Result::Ok
value with the provided closure. Result::Err
values are
unchanged. Read moresource§fn filter_map_ok<F, T, U, E>(self, f: F) -> FilterMapOk<Self, F>where
Self: Iterator<Item = Result<T, E>> + Sized,
F: FnMut(T) -> Option<U>,
fn filter_map_ok<F, T, U, E>(self, f: F) -> FilterMapOk<Self, F>where Self: Iterator<Item = Result<T, E>> + Sized, F: FnMut(T) -> Option<U>,
Result::Ok
value with the provided closure. Result::Err
values are unchanged. Read moresource§fn flatten_ok<T, E>(self) -> FlattenOk<Self, T, E>where
Self: Iterator<Item = Result<T, E>> + Sized,
T: IntoIterator,
fn flatten_ok<T, E>(self) -> FlattenOk<Self, T, E>where Self: Iterator<Item = Result<T, E>> + Sized, T: IntoIterator,
Result::Ok
value into
a series of Result::Ok
values. Result::Err
values are unchanged. Read moresource§fn process_results<F, T, E, R>(self, processor: F) -> Result<R, E>where
Self: Iterator<Item = Result<T, E>> + Sized,
F: FnOnce(ProcessResults<'_, Self, E>) -> R,
fn process_results<F, T, E, R>(self, processor: F) -> Result<R, E>where Self: Iterator<Item = Result<T, E>> + Sized, F: FnOnce(ProcessResults<'_, Self, E>) -> R,
Result
values instead. Read moresource§fn merge<J>(
self,
other: J
) -> MergeBy<Self, <J as IntoIterator>::IntoIter, MergeLte>where
Self: Sized,
Self::Item: PartialOrd,
J: IntoIterator<Item = Self::Item>,
fn merge<J>( self, other: J ) -> MergeBy<Self, <J as IntoIterator>::IntoIter, MergeLte>where Self: Sized, Self::Item: PartialOrd, J: IntoIterator<Item = Self::Item>,
source§fn merge_by<J, F>(
self,
other: J,
is_first: F
) -> MergeBy<Self, <J as IntoIterator>::IntoIter, F>where
Self: Sized,
J: IntoIterator<Item = Self::Item>,
F: FnMut(&Self::Item, &Self::Item) -> bool,
fn merge_by<J, F>( self, other: J, is_first: F ) -> MergeBy<Self, <J as IntoIterator>::IntoIter, F>where Self: Sized, J: IntoIterator<Item = Self::Item>, F: FnMut(&Self::Item, &Self::Item) -> bool,
source§fn merge_join_by<J, F, T>(
self,
other: J,
cmp_fn: F
) -> MergeJoinBy<Self, <J as IntoIterator>::IntoIter, F>where
J: IntoIterator,
F: FnMut(&Self::Item, &<J as IntoIterator>::Item) -> T,
T: OrderingOrBool<Self::Item, <J as IntoIterator>::Item>,
Self: Sized,
fn merge_join_by<J, F, T>( self, other: J, cmp_fn: F ) -> MergeJoinBy<Self, <J as IntoIterator>::IntoIter, F>where J: IntoIterator, F: FnMut(&Self::Item, &<J as IntoIterator>::Item) -> T, T: OrderingOrBool<Self::Item, <J as IntoIterator>::Item>, Self: Sized,
source§fn kmerge(self) -> KMergeBy<<Self::Item as IntoIterator>::IntoIter, KMergeByLt>where
Self: Sized,
Self::Item: IntoIterator,
<Self::Item as IntoIterator>::Item: PartialOrd,
fn kmerge(self) -> KMergeBy<<Self::Item as IntoIterator>::IntoIter, KMergeByLt>where Self: Sized, Self::Item: IntoIterator, <Self::Item as IntoIterator>::Item: PartialOrd,
source§fn kmerge_by<F>(
self,
first: F
) -> KMergeBy<<Self::Item as IntoIterator>::IntoIter, F>where
Self: Sized,
Self::Item: IntoIterator,
F: FnMut(&<Self::Item as IntoIterator>::Item, &<Self::Item as IntoIterator>::Item) -> bool,
fn kmerge_by<F>( self, first: F ) -> KMergeBy<<Self::Item as IntoIterator>::IntoIter, F>where Self: Sized, Self::Item: IntoIterator, F: FnMut(&<Self::Item as IntoIterator>::Item, &<Self::Item as IntoIterator>::Item) -> bool,
source§fn cartesian_product<J>(
self,
other: J
) -> Product<Self, <J as IntoIterator>::IntoIter>where
Self: Sized,
Self::Item: Clone,
J: IntoIterator,
<J as IntoIterator>::IntoIter: Clone,
fn cartesian_product<J>( self, other: J ) -> Product<Self, <J as IntoIterator>::IntoIter>where Self: Sized, Self::Item: Clone, J: IntoIterator, <J as IntoIterator>::IntoIter: Clone,
self
and J
. Read moresource§fn multi_cartesian_product(
self
) -> MultiProduct<<Self::Item as IntoIterator>::IntoIter>where
Self: Sized,
Self::Item: IntoIterator,
<Self::Item as IntoIterator>::IntoIter: Clone,
<Self::Item as IntoIterator>::Item: Clone,
fn multi_cartesian_product( self ) -> MultiProduct<<Self::Item as IntoIterator>::IntoIter>where Self: Sized, Self::Item: IntoIterator, <Self::Item as IntoIterator>::IntoIter: Clone, <Self::Item as IntoIterator>::Item: Clone,
self
. Read moresource§fn coalesce<F>(self, f: F) -> CoalesceBy<Self, F, Self::Item>where
Self: Sized,
F: FnMut(Self::Item, Self::Item) -> Result<Self::Item, (Self::Item, Self::Item)>,
fn coalesce<F>(self, f: F) -> CoalesceBy<Self, F, Self::Item>where Self: Sized, F: FnMut(Self::Item, Self::Item) -> Result<Self::Item, (Self::Item, Self::Item)>,
source§fn dedup(self) -> CoalesceBy<Self, DedupPred2CoalescePred<DedupEq>, Self::Item>where
Self: Sized,
Self::Item: PartialEq,
fn dedup(self) -> CoalesceBy<Self, DedupPred2CoalescePred<DedupEq>, Self::Item>where Self: Sized, Self::Item: PartialEq,
source§fn dedup_by<Cmp>(
self,
cmp: Cmp
) -> CoalesceBy<Self, DedupPred2CoalescePred<Cmp>, Self::Item>where
Self: Sized,
Cmp: FnMut(&Self::Item, &Self::Item) -> bool,
fn dedup_by<Cmp>( self, cmp: Cmp ) -> CoalesceBy<Self, DedupPred2CoalescePred<Cmp>, Self::Item>where Self: Sized, Cmp: FnMut(&Self::Item, &Self::Item) -> bool,
source§fn dedup_with_count(
self
) -> CoalesceBy<Self, DedupPredWithCount2CoalescePred<DedupEq>, (usize, Self::Item)>where
Self: Sized,
fn dedup_with_count( self ) -> CoalesceBy<Self, DedupPredWithCount2CoalescePred<DedupEq>, (usize, Self::Item)>where Self: Sized,
source§fn dedup_by_with_count<Cmp>(
self,
cmp: Cmp
) -> CoalesceBy<Self, DedupPredWithCount2CoalescePred<Cmp>, (usize, Self::Item)>where
Self: Sized,
Cmp: FnMut(&Self::Item, &Self::Item) -> bool,
fn dedup_by_with_count<Cmp>( self, cmp: Cmp ) -> CoalesceBy<Self, DedupPredWithCount2CoalescePred<Cmp>, (usize, Self::Item)>where Self: Sized, Cmp: FnMut(&Self::Item, &Self::Item) -> bool,
source§fn duplicates(self) -> DuplicatesBy<Self, Self::Item, ById>where
Self: Sized,
Self::Item: Eq + Hash,
fn duplicates(self) -> DuplicatesBy<Self, Self::Item, ById>where Self: Sized, Self::Item: Eq + Hash,
source§fn duplicates_by<V, F>(self, f: F) -> DuplicatesBy<Self, V, ByFn<F>>where
Self: Sized,
V: Eq + Hash,
F: FnMut(&Self::Item) -> V,
fn duplicates_by<V, F>(self, f: F) -> DuplicatesBy<Self, V, ByFn<F>>where Self: Sized, V: Eq + Hash, F: FnMut(&Self::Item) -> V,
source§fn unique(self) -> Unique<Self>where
Self: Sized,
Self::Item: Clone + Eq + Hash,
fn unique(self) -> Unique<Self>where Self: Sized, Self::Item: Clone + Eq + Hash,
source§fn unique_by<V, F>(self, f: F) -> UniqueBy<Self, V, F>where
Self: Sized,
V: Eq + Hash,
F: FnMut(&Self::Item) -> V,
fn unique_by<V, F>(self, f: F) -> UniqueBy<Self, V, F>where Self: Sized, V: Eq + Hash, F: FnMut(&Self::Item) -> V,
source§fn peeking_take_while<F>(&mut self, accept: F) -> PeekingTakeWhile<'_, Self, F>where
Self: Sized + PeekingNext,
F: FnMut(&Self::Item) -> bool,
fn peeking_take_while<F>(&mut self, accept: F) -> PeekingTakeWhile<'_, Self, F>where Self: Sized + PeekingNext, F: FnMut(&Self::Item) -> bool,
accept
returns true
. Read moresource§fn take_while_ref<F>(&mut self, accept: F) -> TakeWhileRef<'_, Self, F>where
Self: Clone,
F: FnMut(&Self::Item) -> bool,
fn take_while_ref<F>(&mut self, accept: F) -> TakeWhileRef<'_, Self, F>where Self: Clone, F: FnMut(&Self::Item) -> bool,
Clone
-able iterator
to only pick off elements while the predicate accept
returns true
. Read moresource§fn take_while_inclusive<F>(
&mut self,
accept: F
) -> TakeWhileInclusive<'_, Self, F>where
Self: Sized,
F: FnMut(&Self::Item) -> bool,
fn take_while_inclusive<F>( &mut self, accept: F ) -> TakeWhileInclusive<'_, Self, F>where Self: Sized, F: FnMut(&Self::Item) -> bool,
true
, including the element for which the predicate
first returned false
. Read moresource§fn while_some<A>(self) -> WhileSome<Self>where
Self: Sized + Iterator<Item = Option<A>>,
fn while_some<A>(self) -> WhileSome<Self>where Self: Sized + Iterator<Item = Option<A>>,
Option<A>
iterator elements
and produces A
. Stops on the first None
encountered. Read moresource§fn tuple_combinations<T>(self) -> TupleCombinations<Self, T>where
Self: Sized + Clone,
Self::Item: Clone,
T: HasCombination<Self>,
fn tuple_combinations<T>(self) -> TupleCombinations<Self, T>where Self: Sized + Clone, Self::Item: Clone, T: HasCombination<Self>,
source§fn combinations(self, k: usize) -> Combinations<Self>where
Self: Sized,
Self::Item: Clone,
fn combinations(self, k: usize) -> Combinations<Self>where Self: Sized, Self::Item: Clone,
k
-length combinations of
the elements from an iterator. Read moresource§fn combinations_with_replacement(
self,
k: usize
) -> CombinationsWithReplacement<Self>where
Self: Sized,
Self::Item: Clone,
fn combinations_with_replacement( self, k: usize ) -> CombinationsWithReplacement<Self>where Self: Sized, Self::Item: Clone,
k
-length combinations of
the elements from an iterator, with replacement. Read moresource§fn permutations(self, k: usize) -> Permutations<Self>where
Self: Sized,
Self::Item: Clone,
fn permutations(self, k: usize) -> Permutations<Self>where Self: Sized, Self::Item: Clone,
source§fn powerset(self) -> Powerset<Self>where
Self: Sized,
Self::Item: Clone,
fn powerset(self) -> Powerset<Self>where Self: Sized, Self::Item: Clone,
source§fn pad_using<F>(self, min: usize, f: F) -> PadUsing<Self, F>where
Self: Sized,
F: FnMut(usize) -> Self::Item,
fn pad_using<F>(self, min: usize, f: F) -> PadUsing<Self, F>where Self: Sized, F: FnMut(usize) -> Self::Item,
min
by filling missing elements using a closure f
. Read moresource§fn with_position(self) -> WithPosition<Self>where
Self: Sized,
fn with_position(self) -> WithPosition<Self>where Self: Sized,
Position
to
ease special-case handling of the first or last elements. Read moresource§fn positions<P>(self, predicate: P) -> Positions<Self, P>where
Self: Sized,
P: FnMut(Self::Item) -> bool,
fn positions<P>(self, predicate: P) -> Positions<Self, P>where Self: Sized, P: FnMut(Self::Item) -> bool,
source§fn update<F>(self, updater: F) -> Update<Self, F>where
Self: Sized,
F: FnMut(&mut Self::Item),
fn update<F>(self, updater: F) -> Update<Self, F>where Self: Sized, F: FnMut(&mut Self::Item),
source§fn next_tuple<T>(&mut self) -> Option<T>where
Self: Sized + Iterator<Item = <T as TupleCollect>::Item>,
T: HomogeneousTuple,
fn next_tuple<T>(&mut self) -> Option<T>where Self: Sized + Iterator<Item = <T as TupleCollect>::Item>, T: HomogeneousTuple,
source§fn collect_tuple<T>(self) -> Option<T>where
Self: Sized + Iterator<Item = <T as TupleCollect>::Item>,
T: HomogeneousTuple,
fn collect_tuple<T>(self) -> Option<T>where Self: Sized + Iterator<Item = <T as TupleCollect>::Item>, T: HomogeneousTuple,
source§fn find_position<P>(&mut self, pred: P) -> Option<(usize, Self::Item)>where
P: FnMut(&Self::Item) -> bool,
fn find_position<P>(&mut self, pred: P) -> Option<(usize, Self::Item)>where P: FnMut(&Self::Item) -> bool,
source§fn find_or_last<P>(self, predicate: P) -> Option<Self::Item>where
Self: Sized,
P: FnMut(&Self::Item) -> bool,
fn find_or_last<P>(self, predicate: P) -> Option<Self::Item>where Self: Sized, P: FnMut(&Self::Item) -> bool,
source§fn find_or_first<P>(self, predicate: P) -> Option<Self::Item>where
Self: Sized,
P: FnMut(&Self::Item) -> bool,
fn find_or_first<P>(self, predicate: P) -> Option<Self::Item>where Self: Sized, P: FnMut(&Self::Item) -> bool,
source§fn contains<Q>(&mut self, query: &Q) -> boolwhere
Self: Sized,
Self::Item: Borrow<Q>,
Q: PartialEq,
fn contains<Q>(&mut self, query: &Q) -> boolwhere Self: Sized, Self::Item: Borrow<Q>, Q: PartialEq,
true
if the given item is present in this iterator. Read moresource§fn all_equal(&mut self) -> boolwhere
Self: Sized,
Self::Item: PartialEq,
fn all_equal(&mut self) -> boolwhere Self: Sized, Self::Item: PartialEq,
source§fn all_equal_value(
&mut self
) -> Result<Self::Item, Option<(Self::Item, Self::Item)>>where
Self: Sized,
Self::Item: PartialEq,
fn all_equal_value( &mut self ) -> Result<Self::Item, Option<(Self::Item, Self::Item)>>where Self: Sized, Self::Item: PartialEq,
source§fn all_unique(&mut self) -> boolwhere
Self: Sized,
Self::Item: Eq + Hash,
fn all_unique(&mut self) -> boolwhere Self: Sized, Self::Item: Eq + Hash,
source§fn dropping(self, n: usize) -> Selfwhere
Self: Sized,
fn dropping(self, n: usize) -> Selfwhere Self: Sized,
n
elements from the iterator eagerly,
and return the same iterator again. Read moresource§fn dropping_back(self, n: usize) -> Selfwhere
Self: Sized + DoubleEndedIterator,
fn dropping_back(self, n: usize) -> Selfwhere Self: Sized + DoubleEndedIterator,
n
elements from the iterator eagerly,
and return the same iterator again. Read moresource§fn foreach<F>(self, f: F)where
F: FnMut(Self::Item),
Self: Sized,
fn foreach<F>(self, f: F)where F: FnMut(Self::Item), Self: Sized,
f
eagerly on each element of the iterator. Read moresource§fn concat(self) -> Self::Itemwhere
Self: Sized,
Self::Item: Extend<<Self::Item as IntoIterator>::Item> + IntoIterator + Default,
fn concat(self) -> Self::Itemwhere Self: Sized, Self::Item: Extend<<Self::Item as IntoIterator>::Item> + IntoIterator + Default,
source§fn collect_vec(self) -> Vec<Self::Item>where
Self: Sized,
fn collect_vec(self) -> Vec<Self::Item>where Self: Sized,
.collect_vec()
is simply a type specialization of Iterator::collect
,
for convenience.source§fn try_collect<T, U, E>(self) -> Result<U, E>where
Self: Sized + Iterator<Item = Result<T, E>>,
Result<U, E>: FromIterator<Result<T, E>>,
fn try_collect<T, U, E>(self) -> Result<U, E>where Self: Sized + Iterator<Item = Result<T, E>>, Result<U, E>: FromIterator<Result<T, E>>,
source§fn set_from<'a, A, J>(&mut self, from: J) -> usizewhere
A: 'a,
Self: Iterator<Item = &'a mut A>,
J: IntoIterator<Item = A>,
fn set_from<'a, A, J>(&mut self, from: J) -> usizewhere A: 'a, Self: Iterator<Item = &'a mut A>, J: IntoIterator<Item = A>,
self
from the from
iterator,
stopping at the shortest of the two iterators. Read moresource§fn join(&mut self, sep: &str) -> Stringwhere
Self::Item: Display,
fn join(&mut self, sep: &str) -> Stringwhere Self::Item: Display,
sep
. Read moresource§fn format(self, sep: &str) -> Format<'_, Self>where
Self: Sized,
fn format(self, sep: &str) -> Format<'_, Self>where Self: Sized,
sep
. Read moresource§fn format_with<F>(self, sep: &str, format: F) -> FormatWith<'_, Self, F>where
Self: Sized,
F: FnMut(Self::Item, &mut dyn FnMut(&dyn Display) -> Result<(), Error>) -> Result<(), Error>,
fn format_with<F>(self, sep: &str, format: F) -> FormatWith<'_, Self, F>where Self: Sized, F: FnMut(Self::Item, &mut dyn FnMut(&dyn Display) -> Result<(), Error>) -> Result<(), Error>,
sep
. Read moresource§fn fold_results<A, E, B, F>(&mut self, start: B, f: F) -> Result<B, E>where
Self: Iterator<Item = Result<A, E>>,
F: FnMut(B, A) -> B,
fn fold_results<A, E, B, F>(&mut self, start: B, f: F) -> Result<B, E>where Self: Iterator<Item = Result<A, E>>, F: FnMut(B, A) -> B,
.fold_ok()
.source§fn fold_ok<A, E, B, F>(&mut self, start: B, f: F) -> Result<B, E>where
Self: Iterator<Item = Result<A, E>>,
F: FnMut(B, A) -> B,
fn fold_ok<A, E, B, F>(&mut self, start: B, f: F) -> Result<B, E>where Self: Iterator<Item = Result<A, E>>, F: FnMut(B, A) -> B,
Result
values from an iterator. Read moresource§fn fold_options<A, B, F>(&mut self, start: B, f: F) -> Option<B>where
Self: Iterator<Item = Option<A>>,
F: FnMut(B, A) -> B,
fn fold_options<A, B, F>(&mut self, start: B, f: F) -> Option<B>where Self: Iterator<Item = Option<A>>, F: FnMut(B, A) -> B,
Option
values from an iterator. Read moresource§fn fold1<F>(self, f: F) -> Option<Self::Item>where
F: FnMut(Self::Item, Self::Item) -> Self::Item,
Self: Sized,
fn fold1<F>(self, f: F) -> Option<Self::Item>where F: FnMut(Self::Item, Self::Item) -> Self::Item, Self: Sized,
Iterator::reduce
insteadsource§fn tree_fold1<F>(self, f: F) -> Option<Self::Item>where
F: FnMut(Self::Item, Self::Item) -> Self::Item,
Self: Sized,
fn tree_fold1<F>(self, f: F) -> Option<Self::Item>where F: FnMut(Self::Item, Self::Item) -> Self::Item, Self: Sized,
source§fn fold_while<B, F>(&mut self, init: B, f: F) -> FoldWhile<B>where
Self: Sized,
F: FnMut(B, Self::Item) -> FoldWhile<B>,
fn fold_while<B, F>(&mut self, init: B, f: F) -> FoldWhile<B>where Self: Sized, F: FnMut(B, Self::Item) -> FoldWhile<B>,
source§fn sum1<S>(self) -> Option<S>where
Self: Sized,
S: Sum<Self::Item>,
fn sum1<S>(self) -> Option<S>where Self: Sized, S: Sum<Self::Item>,
source§fn product1<P>(self) -> Option<P>where
Self: Sized,
P: Product<Self::Item>,
fn product1<P>(self) -> Option<P>where Self: Sized, P: Product<Self::Item>,
source§fn sorted_unstable(self) -> IntoIter<Self::Item>where
Self: Sized,
Self::Item: Ord,
fn sorted_unstable(self) -> IntoIter<Self::Item>where Self: Sized, Self::Item: Ord,
source§fn sorted_unstable_by<F>(self, cmp: F) -> IntoIter<Self::Item>where
Self: Sized,
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
fn sorted_unstable_by<F>(self, cmp: F) -> IntoIter<Self::Item>where Self: Sized, F: FnMut(&Self::Item, &Self::Item) -> Ordering,
source§fn sorted_unstable_by_key<K, F>(self, f: F) -> IntoIter<Self::Item>where
Self: Sized,
K: Ord,
F: FnMut(&Self::Item) -> K,
fn sorted_unstable_by_key<K, F>(self, f: F) -> IntoIter<Self::Item>where Self: Sized, K: Ord, F: FnMut(&Self::Item) -> K,
source§fn sorted(self) -> IntoIter<Self::Item>where
Self: Sized,
Self::Item: Ord,
fn sorted(self) -> IntoIter<Self::Item>where Self: Sized, Self::Item: Ord,
source§fn sorted_by<F>(self, cmp: F) -> IntoIter<Self::Item>where
Self: Sized,
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
fn sorted_by<F>(self, cmp: F) -> IntoIter<Self::Item>where Self: Sized, F: FnMut(&Self::Item, &Self::Item) -> Ordering,
source§fn sorted_by_key<K, F>(self, f: F) -> IntoIter<Self::Item>where
Self: Sized,
K: Ord,
F: FnMut(&Self::Item) -> K,
fn sorted_by_key<K, F>(self, f: F) -> IntoIter<Self::Item>where Self: Sized, K: Ord, F: FnMut(&Self::Item) -> K,
source§fn sorted_by_cached_key<K, F>(self, f: F) -> IntoIter<Self::Item>where
Self: Sized,
K: Ord,
F: FnMut(&Self::Item) -> K,
fn sorted_by_cached_key<K, F>(self, f: F) -> IntoIter<Self::Item>where Self: Sized, K: Ord, F: FnMut(&Self::Item) -> K,
source§fn k_smallest(self, k: usize) -> IntoIter<Self::Item>where
Self: Sized,
Self::Item: Ord,
fn k_smallest(self, k: usize) -> IntoIter<Self::Item>where Self: Sized, Self::Item: Ord,
source§fn partition_map<A, B, F, L, R>(self, predicate: F) -> (A, B)where
Self: Sized,
F: FnMut(Self::Item) -> Either<L, R>,
A: Default + Extend<L>,
B: Default + Extend<R>,
fn partition_map<A, B, F, L, R>(self, predicate: F) -> (A, B)where Self: Sized, F: FnMut(Self::Item) -> Either<L, R>, A: Default + Extend<L>, B: Default + Extend<R>,
Iterator::partition
, each partition may
have a distinct type. Read moresource§fn partition_result<A, B, T, E>(self) -> (A, B)where
Self: Iterator<Item = Result<T, E>> + Sized,
A: Default + Extend<T>,
B: Default + Extend<E>,
fn partition_result<A, B, T, E>(self) -> (A, B)where Self: Iterator<Item = Result<T, E>> + Sized, A: Default + Extend<T>, B: Default + Extend<E>,
Result
s into one list of all the Ok
elements
and another list of all the Err
elements. Read moresource§fn into_group_map<K, V>(self) -> HashMap<K, Vec<V>>where
Self: Iterator<Item = (K, V)> + Sized,
K: Hash + Eq,
fn into_group_map<K, V>(self) -> HashMap<K, Vec<V>>where Self: Iterator<Item = (K, V)> + Sized, K: Hash + Eq,
HashMap
of keys mapped to Vec
s of values. Keys and values
are taken from (Key, Value)
tuple pairs yielded by the input iterator. Read moresource§fn into_group_map_by<K, V, F>(self, f: F) -> HashMap<K, Vec<V>>where
Self: Iterator<Item = V> + Sized,
K: Hash + Eq,
F: Fn(&V) -> K,
fn into_group_map_by<K, V, F>(self, f: F) -> HashMap<K, Vec<V>>where Self: Iterator<Item = V> + Sized, K: Hash + Eq, F: Fn(&V) -> K,
Iterator
on a HashMap
. Keys mapped to Vec
s of values. The key is specified
in the closure. Read moresource§fn into_grouping_map<K, V>(self) -> GroupingMap<Self>where
Self: Iterator<Item = (K, V)> + Sized,
K: Hash + Eq,
fn into_grouping_map<K, V>(self) -> GroupingMap<Self>where Self: Iterator<Item = (K, V)> + Sized, K: Hash + Eq,
GroupingMap
to be used later with one of the efficient
group-and-fold operations it allows to perform. Read moresource§fn into_grouping_map_by<K, V, F>(
self,
key_mapper: F
) -> GroupingMap<MapForGrouping<Self, F>>where
Self: Iterator<Item = V> + Sized,
K: Hash + Eq,
F: FnMut(&V) -> K,
fn into_grouping_map_by<K, V, F>( self, key_mapper: F ) -> GroupingMap<MapForGrouping<Self, F>>where Self: Iterator<Item = V> + Sized, K: Hash + Eq, F: FnMut(&V) -> K,
GroupingMap
to be used later with one of the efficient
group-and-fold operations it allows to perform. Read moresource§fn min_set(self) -> Vec<Self::Item>where
Self: Sized,
Self::Item: Ord,
fn min_set(self) -> Vec<Self::Item>where Self: Sized, Self::Item: Ord,
source§fn min_set_by<F>(self, compare: F) -> Vec<Self::Item>where
Self: Sized,
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
fn min_set_by<F>(self, compare: F) -> Vec<Self::Item>where Self: Sized, F: FnMut(&Self::Item, &Self::Item) -> Ordering,
source§fn min_set_by_key<K, F>(self, key: F) -> Vec<Self::Item>where
Self: Sized,
K: Ord,
F: FnMut(&Self::Item) -> K,
fn min_set_by_key<K, F>(self, key: F) -> Vec<Self::Item>where Self: Sized, K: Ord, F: FnMut(&Self::Item) -> K,
source§fn max_set(self) -> Vec<Self::Item>where
Self: Sized,
Self::Item: Ord,
fn max_set(self) -> Vec<Self::Item>where Self: Sized, Self::Item: Ord,
source§fn max_set_by<F>(self, compare: F) -> Vec<Self::Item>where
Self: Sized,
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
fn max_set_by<F>(self, compare: F) -> Vec<Self::Item>where Self: Sized, F: FnMut(&Self::Item, &Self::Item) -> Ordering,
source§fn max_set_by_key<K, F>(self, key: F) -> Vec<Self::Item>where
Self: Sized,
K: Ord,
F: FnMut(&Self::Item) -> K,
fn max_set_by_key<K, F>(self, key: F) -> Vec<Self::Item>where Self: Sized, K: Ord, F: FnMut(&Self::Item) -> K,
source§fn minmax(self) -> MinMaxResult<Self::Item>where
Self: Sized,
Self::Item: PartialOrd,
fn minmax(self) -> MinMaxResult<Self::Item>where Self: Sized, Self::Item: PartialOrd,
source§fn minmax_by_key<K, F>(self, key: F) -> MinMaxResult<Self::Item>where
Self: Sized,
K: PartialOrd,
F: FnMut(&Self::Item) -> K,
fn minmax_by_key<K, F>(self, key: F) -> MinMaxResult<Self::Item>where Self: Sized, K: PartialOrd, F: FnMut(&Self::Item) -> K,
source§fn minmax_by<F>(self, compare: F) -> MinMaxResult<Self::Item>where
Self: Sized,
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
fn minmax_by<F>(self, compare: F) -> MinMaxResult<Self::Item>where Self: Sized, F: FnMut(&Self::Item, &Self::Item) -> Ordering,
source§fn position_max(self) -> Option<usize>where
Self: Sized,
Self::Item: Ord,
fn position_max(self) -> Option<usize>where Self: Sized, Self::Item: Ord,
source§fn position_max_by_key<K, F>(self, key: F) -> Option<usize>where
Self: Sized,
K: Ord,
F: FnMut(&Self::Item) -> K,
fn position_max_by_key<K, F>(self, key: F) -> Option<usize>where Self: Sized, K: Ord, F: FnMut(&Self::Item) -> K,
source§fn position_max_by<F>(self, compare: F) -> Option<usize>where
Self: Sized,
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
fn position_max_by<F>(self, compare: F) -> Option<usize>where Self: Sized, F: FnMut(&Self::Item, &Self::Item) -> Ordering,
source§fn position_min(self) -> Option<usize>where
Self: Sized,
Self::Item: Ord,
fn position_min(self) -> Option<usize>where Self: Sized, Self::Item: Ord,
source§fn position_min_by_key<K, F>(self, key: F) -> Option<usize>where
Self: Sized,
K: Ord,
F: FnMut(&Self::Item) -> K,
fn position_min_by_key<K, F>(self, key: F) -> Option<usize>where Self: Sized, K: Ord, F: FnMut(&Self::Item) -> K,
source§fn position_min_by<F>(self, compare: F) -> Option<usize>where
Self: Sized,
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
fn position_min_by<F>(self, compare: F) -> Option<usize>where Self: Sized, F: FnMut(&Self::Item, &Self::Item) -> Ordering,
source§fn position_minmax(self) -> MinMaxResult<usize>where
Self: Sized,
Self::Item: PartialOrd,
fn position_minmax(self) -> MinMaxResult<usize>where Self: Sized, Self::Item: PartialOrd,
source§fn position_minmax_by_key<K, F>(self, key: F) -> MinMaxResult<usize>where
Self: Sized,
K: PartialOrd,
F: FnMut(&Self::Item) -> K,
fn position_minmax_by_key<K, F>(self, key: F) -> MinMaxResult<usize>where Self: Sized, K: PartialOrd, F: FnMut(&Self::Item) -> K,
source§fn position_minmax_by<F>(self, compare: F) -> MinMaxResult<usize>where
Self: Sized,
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
fn position_minmax_by<F>(self, compare: F) -> MinMaxResult<usize>where Self: Sized, F: FnMut(&Self::Item, &Self::Item) -> Ordering,
source§fn exactly_one(self) -> Result<Self::Item, ExactlyOneError<Self>>where
Self: Sized,
fn exactly_one(self) -> Result<Self::Item, ExactlyOneError<Self>>where Self: Sized,
source§fn at_most_one(self) -> Result<Option<Self::Item>, ExactlyOneError<Self>>where
Self: Sized,
fn at_most_one(self) -> Result<Option<Self::Item>, ExactlyOneError<Self>>where Self: Sized,
source§fn multipeek(self) -> MultiPeek<Self>where
Self: Sized,
fn multipeek(self) -> MultiPeek<Self>where Self: Sized,
.next()
values without advancing the base iterator. Read moresource§fn counts(self) -> HashMap<Self::Item, usize>where
Self: Sized,
Self::Item: Eq + Hash,
fn counts(self) -> HashMap<Self::Item, usize>where Self: Sized, Self::Item: Eq + Hash,
HashMap
which
contains each item that appears in the iterator and the number
of times it appears. Read moresource§fn counts_by<K, F>(self, f: F) -> HashMap<K, usize>where
Self: Sized,
K: Eq + Hash,
F: FnMut(Self::Item) -> K,
fn counts_by<K, F>(self, f: F) -> HashMap<K, usize>where Self: Sized, K: Eq + Hash, F: FnMut(Self::Item) -> K,
HashMap
which
contains each item that appears in the iterator and the number
of times it appears,
determining identity using a keying function. Read more