pub struct PyIterator<'a, T> { /* fields omitted */ }
impl<'a, T>Iterator forPyIterator<'a, T>where
T:TryFromObject,
[src]typeItem =PyResult<T>
The type of the elements being iterated over.
fnnext(&mut self) ->Option<Self::Item>
[src]fnsize_hint(&self) ->(usize,Option<usize>)
1.0.0[src]fncount(self) ->usize
1.0.0[src]fnlast(self) ->Option<Self::Item>
1.0.0[src]fnnth(&mut self, n:usize) ->Option<Self::Item>
1.0.0[src]fnstep_by(self, step:usize) ->StepBy<Self>
1.28.0[src]fnchain<U>(self, other: U) ->Chain<Self, <U asIntoIterator>::IntoIter>where
U:IntoIterator<Item = Self::Item>,
1.0.0[src]fnzip<U>(self, other: U) ->Zip<Self, <U asIntoIterator>::IntoIter>where
U:IntoIterator,
1.0.0[src]fnmap<B, F>(self, f: F) ->Map<Self, F>where
F:FnMut(Self::Item) -> B,
1.0.0[src]fnfor_each<F>(self, f: F)where
F:FnMut(Self::Item),
1.21.0[src]fnfilter<P>(self, predicate: P) ->Filter<Self, P>where
P:FnMut(&Self::Item) ->bool,
1.0.0[src]fnfilter_map<B, F>(self, f: F) ->FilterMap<Self, F>where
F:FnMut(Self::Item) ->Option<B>,
1.0.0[src]fnenumerate(self) ->Enumerate<Self>
1.0.0[src]fnpeekable(self) ->Peekable<Self>
1.0.0[src]fnskip_while<P>(self, predicate: P) ->SkipWhile<Self, P>where
P:FnMut(&Self::Item) ->bool,
1.0.0[src]fntake_while<P>(self, predicate: P) ->TakeWhile<Self, P>where
P:FnMut(&Self::Item) ->bool,
1.0.0[src]fnskip(self, n:usize) ->Skip<Self>
1.0.0[src]fntake(self, n:usize) ->Take<Self>
1.0.0[src]fnscan<St, B, F>(self, initial_state: St, f: F) ->Scan<Self, St, F>where
F:FnMut(&mutSt, Self::Item) ->Option<B>,
1.0.0[src]fnflat_map<U, F>(self, f: F) ->FlatMap<Self, U, F>where
F:FnMut(Self::Item) -> U,
U:IntoIterator,
1.0.0[src]fnflatten(self) ->Flatten<Self>where
Self::Item:IntoIterator,
1.29.0[src]fnfuse(self) ->Fuse<Self>
1.0.0[src]fninspect<F>(self, f: F) ->Inspect<Self, F>where
F:FnMut(&Self::Item),
1.0.0[src]fnby_ref(&mut self) ->&mutSelf
1.0.0[src]#[must_use = "if you really need to exhaust the iterator, consider `.for_each(drop)` instead"]fncollect<B>(self) -> Bwhere
B:FromIterator<Self::Item>,
1.0.0[src]fnpartition<B, F>(self, f: F) ->(B, B)where
B:Default +Extend<Self::Item>,
F:FnMut(&Self::Item) ->bool,
1.0.0[src]fnpartition_in_place<'a, T, P>(self, predicate: P) ->usizewhere
P:FnMut(&T) ->bool,
Self:DoubleEndedIterator<Item =&'a mutT>,
T: 'a,
[src]fnis_partitioned<P>(self, predicate: P) ->boolwhere
P:FnMut(Self::Item) ->bool,
[src]fntry_fold<B, F, R>(&mut self, init: B, f: F) -> Rwhere
F:FnMut(B, Self::Item) -> R,
R:Try<Ok = B>,
1.27.0[src]fntry_for_each<F, R>(&mut self, f: F) -> Rwhere
F:FnMut(Self::Item) -> R,
R:Try<Ok =()>,
1.27.0[src]fnfold<B, F>(self, init: B, f: F) -> Bwhere
F:FnMut(B, Self::Item) -> B,
1.0.0[src]fnall<F>(&mut self, f: F) ->boolwhere
F:FnMut(Self::Item) ->bool,
1.0.0[src]fnany<F>(&mut self, f: F) ->boolwhere
F:FnMut(Self::Item) ->bool,
1.0.0[src]fnfind<P>(&mut self, predicate: P) ->Option<Self::Item>where
P:FnMut(&Self::Item) ->bool,
1.0.0[src]fnfind_map<B, F>(&mut self, f: F) ->Option<B>where
F:FnMut(Self::Item) ->Option<B>,
1.30.0[src]fnposition<P>(&mut self, predicate: P) ->Option<usize>where
P:FnMut(Self::Item) ->bool,
1.0.0[src]fnrposition<P>(&mut self, predicate: P) ->Option<usize>where
P:FnMut(Self::Item) ->bool,
Self:ExactSizeIterator +DoubleEndedIterator,
1.0.0[src]fnmax(self) ->Option<Self::Item>where
Self::Item:Ord,
1.0.0[src]fnmin(self) ->Option<Self::Item>where
Self::Item:Ord,
1.0.0[src]fnmax_by_key<B, F>(self, f: F) ->Option<Self::Item>where
B:Ord,
F:FnMut(&Self::Item) -> B,
1.6.0[src]fnmax_by<F>(self, compare: F) ->Option<Self::Item>where
F:FnMut(&Self::Item, &Self::Item) ->Ordering,
1.15.0[src]fnmin_by_key<B, F>(self, f: F) ->Option<Self::Item>where
B:Ord,
F:FnMut(&Self::Item) -> B,
1.6.0[src]fnmin_by<F>(self, compare: F) ->Option<Self::Item>where
F:FnMut(&Self::Item, &Self::Item) ->Ordering,
1.15.0[src]fnrev(self) ->Rev<Self>where
Self:DoubleEndedIterator,
1.0.0[src]fnunzip<A, B, FromA, FromB>(self) ->(FromA, FromB)where
FromA:Default +Extend<A>,
FromB:Default +Extend<B>,
Self:Iterator<Item =(A, B)>,
1.0.0[src]fncopied<'a, T>(self) ->Copied<Self>where
Self:Iterator<Item =&'aT>,
T: 'a +Copy,
1.36.0[src]fncloned<'a, T>(self) ->Cloned<Self>where
Self:Iterator<Item =&'aT>,
T: 'a +Clone,
1.0.0[src]fncycle(self) ->Cycle<Self>where
Self:Clone,
1.0.0[src]fnsum<S>(self) -> Swhere
S:Sum<Self::Item>,
1.11.0[src]fnproduct<P>(self) -> Pwhere
P:Product<Self::Item>,
1.11.0[src]fncmp<I>(self, other: I) ->Orderingwhere
I:IntoIterator<Item = Self::Item>,
Self::Item:Ord,
1.5.0[src]fncmp_by<I, F>(self, other: I, cmp: F) ->Orderingwhere
F:FnMut(Self::Item, <I asIntoIterator>::Item) ->Ordering,
I:IntoIterator,
[src]fnpartial_cmp<I>(self, other: I) ->Option<Ordering>where
I:IntoIterator,
Self::Item:PartialOrd<<I asIntoIterator>::Item>,
1.5.0[src]fnpartial_cmp_by<I, F>(self, other: I, partial_cmp: F) ->Option<Ordering>where
F:FnMut(Self::Item, <I asIntoIterator>::Item) ->Option<Ordering>,
I:IntoIterator,
[src]fneq<I>(self, other: I) ->boolwhere
I:IntoIterator,
Self::Item:PartialEq<<I asIntoIterator>::Item>,
1.5.0[src]fneq_by<I, F>(self, other: I, eq: F) ->boolwhere
F:FnMut(Self::Item, <I asIntoIterator>::Item) ->bool,
I:IntoIterator,
[src]fnne<I>(self, other: I) ->boolwhere
I:IntoIterator,
Self::Item:PartialEq<<I asIntoIterator>::Item>,
1.5.0[src]fnlt<I>(self, other: I) ->boolwhere
I:IntoIterator,
Self::Item:PartialOrd<<I asIntoIterator>::Item>,
1.5.0[src]fnle<I>(self, other: I) ->boolwhere
I:IntoIterator,
Self::Item:PartialOrd<<I asIntoIterator>::Item>,
1.5.0[src]fngt<I>(self, other: I) ->boolwhere
I:IntoIterator,
Self::Item:PartialOrd<<I asIntoIterator>::Item>,
1.5.0[src]fnge<I>(self, other: I) ->boolwhere
I:IntoIterator,
Self::Item:PartialOrd<<I asIntoIterator>::Item>,
1.5.0[src]fnis_sorted(self) ->boolwhere
Self::Item:PartialOrd<Self::Item>,
[src]fnis_sorted_by<F>(self, compare: F) ->boolwhere
F:FnMut(&Self::Item, &Self::Item) ->Option<Ordering>,
[src]fnis_sorted_by_key<F, K>(self, f: F) ->boolwhere
F:FnMut(Self::Item) -> K,
K:PartialOrd<K>,
[src]impl<'a, T> !RefUnwindSafe forPyIterator<'a, T>
impl<'a, T> !Send forPyIterator<'a, T>
impl<'a, T> !Sync forPyIterator<'a, T>
impl<'a, T>Unpin forPyIterator<'a, T>where
T:Unpin,
impl<'a, T> !UnwindSafe forPyIterator<'a, T>
impl<T>Any for Twhere
T: 'static + ?Sized,
[src]impl<T>Borrow<T> for Twhere
T: ?Sized,
[src]impl<T>BorrowMut<T> for Twhere
T: ?Sized,
[src]fnborrow_mut(&mut self) ->&mutT
[src]impl<T>From<T> for T
[src]impl<T, U>Into<U> for Twhere
U:From<T>,
[src]impl<I>IntoIterator for Iwhere
I:Iterator,
[src]typeItem = <I asIterator>::Item
The type of the elements being iterated over.
typeIntoIter = I
Which kind of iterator are we turning this into?
fninto_iter(self) -> I
[src]impl<I>IteratorRandom for Iwhere
I:Iterator,
[src]fnchoose<R>(self, rng:&mutR) ->Option<Self::Item>where
R:Rng + ?Sized,
[src]fnchoose_multiple_fill<R>(self, rng:&mutR, buf:&mut [Self::Item]) ->usizewhere
R:Rng + ?Sized,
[src]fnchoose_multiple<R>(self, rng:&mutR, amount:usize) ->Vec<Self::Item>where
R:Rng + ?Sized,
[src]impl<T>Itertools for Twhere
T:Iterator + ?Sized,
[src]fninterleave<J>(
self,
other: J
) ->Interleave<Self, <J asIntoIterator>::IntoIter>where
J:IntoIterator<Item = Self::Item>,
[src]fninterleave_shortest<J>(
self,
other: J
) ->InterleaveShortest<Self, <J asIntoIterator>::IntoIter>where
J:IntoIterator<Item = Self::Item>,
[src]fnintersperse(self, element: Self::Item) ->Intersperse<Self>where
Self::Item:Clone,
[src]fnzip_longest<J>(
self,
other: J
) ->ZipLongest<Self, <J asIntoIterator>::IntoIter>where
J:IntoIterator,
[src]fnzip_eq<J>(self, other: J) ->ZipEq<Self, <J asIntoIterator>::IntoIter>where
J:IntoIterator,
[src]fnbatching<B, F>(self, f: F) ->Batching<Self, F>where
F:FnMut(&mutSelf) ->Option<B>,
[src]fngroup_by<K, F>(self, key: F) ->GroupBy<K, Self, F>where
F:FnMut(&Self::Item) -> K,
K:PartialEq<K>,
[src]fnchunks(self, size:usize) ->IntoChunks<Self>
[src]fntuple_windows<T>(self) ->TupleWindows<Self, T>where
Self:Iterator<Item = <T as TupleCollect>::Item>,
T: TupleCollect,
<T as TupleCollect>::Item:Clone,
[src]fntuples<T>(self) ->Tuples<Self, T>where
Self:Iterator<Item = <T as TupleCollect>::Item>,
T: TupleCollect,
[src]fntee(self) ->(Tee<Self>,Tee<Self>)where
Self::Item:Clone,
[src]fnstep(self, n:usize) ->Step<Self>
[src]fnmap_into<R>(self) ->MapInto<Self, R>where
Self::Item:Into<R>,
[src]fnmap_results<F, T, U, E>(self, f: F) ->MapResults<Self, F>where
F:FnMut(T) -> U,
Self:Iterator<Item =Result<T, E>>,
[src]fnmerge<J>(
self,
other: J
) ->MergeBy<Self, <J asIntoIterator>::IntoIter, MergeLte>where
J:IntoIterator<Item = Self::Item>,
Self::Item:PartialOrd<Self::Item>,
[src]fnmerge_by<J, F>(
self,
other: J,
is_first: F
) ->MergeBy<Self, <J asIntoIterator>::IntoIter, F>where
F:FnMut(&Self::Item, &Self::Item) ->bool,
J:IntoIterator<Item = Self::Item>,
[src]fnmerge_join_by<J, F>(
self,
other: J,
cmp_fn: F
) ->MergeJoinBy<Self, <J asIntoIterator>::IntoIter, F>where
F:FnMut(&Self::Item, &<J asIntoIterator>::Item) ->Ordering,
J:IntoIterator,
[src]fnkmerge(self) ->KMergeBy<<Self::Item asIntoIterator>::IntoIter, KMergeByLt>where
Self::Item:IntoIterator,
<Self::Item asIntoIterator>::Item:PartialOrd<<Self::Item asIntoIterator>::Item>,
[src]fnkmerge_by<F>(
self,
first: F
) ->KMergeBy<<Self::Item asIntoIterator>::IntoIter, F>where
F:FnMut(&<Self::Item asIntoIterator>::Item, &<Self::Item asIntoIterator>::Item) ->bool,
Self::Item:IntoIterator,
[src]fncartesian_product<J>(
self,
other: J
) ->Product<Self, <J asIntoIterator>::IntoIter>where
J:IntoIterator,
Self::Item:Clone,
<J asIntoIterator>::IntoIter:Clone,
[src]fnmulti_cartesian_product(
self
) ->MultiProduct<<Self::Item asIntoIterator>::IntoIter>where
Self:Iterator,
Self::Item:IntoIterator,
<Self::Item asIntoIterator>::IntoIter:Clone,
<Self::Item asIntoIterator>::Item:Clone,
[src]fncoalesce<F>(self, f: F) ->Coalesce<Self, F>where
F:FnMut(Self::Item, Self::Item) ->Result<Self::Item,(Self::Item, Self::Item)>,
[src]fndedup(self) ->DedupBy<Self, DedupEq>where
Self::Item:PartialEq<Self::Item>,
[src]fndedup_by<Cmp>(self, cmp: Cmp) ->DedupBy<Self, Cmp>where
Cmp:FnMut(&Self::Item, &Self::Item) ->bool,
[src]fnunique(self) ->Unique<Self>where
Self::Item:Clone,
Self::Item:Eq,
Self::Item:Hash,
[src]fnunique_by<V, F>(self, f: F) ->UniqueBy<Self, V, F>where
F:FnMut(&Self::Item) -> V,
V:Eq +Hash,
[src]fnpeeking_take_while<F>(&mut self, accept: F) ->PeekingTakeWhile<Self, F>where
F:FnMut(&Self::Item) ->bool,
Self:PeekingNext,
[src]fntake_while_ref<F>(&mut self, accept: F) ->TakeWhileRef<Self, F>where
F:FnMut(&Self::Item) ->bool,
Self:Clone,
[src]fnwhile_some<A>(self) ->WhileSome<Self>where
Self:Iterator<Item =Option<A>>,
[src]fntuple_combinations<T>(self) ->TupleCombinations<Self, T>where
Self:Clone,
T: HasCombination<Self>,
Self::Item:Clone,
[src]fncombinations(self, k:usize) ->Combinations<Self>where
Self::Item:Clone,
[src]fncombinations_with_replacement(
self,
k:usize
) ->CombinationsWithReplacement<Self>where
Self::Item:Clone,
[src]fnpermutations(self, k:usize) ->Permutations<Self>where
Self::Item:Clone,
[src]fnpad_using<F>(self, min:usize, f: F) ->PadUsing<Self, F>where
F:FnMut(usize) -> Self::Item,
[src]fnwith_position(self) ->WithPosition<Self>
[src]fnpositions<P>(self, predicate: P) ->Positions<Self, P>where
P:FnMut(Self::Item) ->bool,
[src]fnupdate<F>(self, updater: F) ->Update<Self, F>where
F:FnMut(&mut Self::Item),
[src]fnnext_tuple<T>(&mut self) ->Option<T>where
Self:Iterator<Item = <T as TupleCollect>::Item>,
T: TupleCollect,
[src]fncollect_tuple<T>(self) ->Option<T>where
Self:Iterator<Item = <T as TupleCollect>::Item>,
T: TupleCollect,
[src]fnfind_position<P>(&mut self, pred: P) ->Option<(usize, Self::Item)>where
P:FnMut(&Self::Item) ->bool,
[src]fnall_equal(&mut self) ->boolwhere
Self::Item:PartialEq<Self::Item>,
[src]fndropping(self, n:usize) -> Self
[src]fndropping_back(self, n:usize) -> Selfwhere
Self:DoubleEndedIterator,
[src]fnforeach<F>(self, f: F)where
F:FnMut(Self::Item),
[src]fnconcat(self) -> Self::Itemwhere
Self::Item:Extend<<Self::Item asIntoIterator>::Item>,
Self::Item:IntoIterator,
Self::Item:Default,
[src]fncollect_vec(self) ->Vec<Self::Item>
[src]fnset_from<'a, A, J>(&mut self, from: J) ->usizewhere
A: 'a,
J:IntoIterator<Item = A>,
Self:Iterator<Item =&'a mutA>,
[src]fnjoin(&mut self, sep: &str) ->Stringwhere
Self::Item:Display,
[src]fnformat(self, sep: &str) ->Format<Self>
[src]fnformat_with<F>(self, sep: &str, format: F) ->FormatWith<Self, F>where
F:FnMut(Self::Item, &mut dynFnMut(&dynDisplay)) ->Result<(),Error>,
[src]fnfold_results<A, E, B, F>(&mut self, start: B, f: F) ->Result<B, E>where
F:FnMut(B, A) -> B,
Self:Iterator<Item =Result<A, E>>,
[src]fnfold_options<A, B, F>(&mut self, start: B, f: F) ->Option<B>where
F:FnMut(B, A) -> B,
Self:Iterator<Item =Option<A>>,
[src]fnfold1<F>(self, f: F) ->Option<Self::Item>where
F:FnMut(Self::Item, Self::Item) -> Self::Item,
[src]fntree_fold1<F>(self, f: F) ->Option<Self::Item>where
F:FnMut(Self::Item, Self::Item) -> Self::Item,
[src]fnfold_while<B, F>(&mut self, init: B, f: F) ->FoldWhile<B>where
F:FnMut(B, Self::Item) ->FoldWhile<B>,
[src]fnsum1<S>(self) ->Option<S>where
S:Sum<Self::Item>,
[src]fnproduct1<P>(self) ->Option<P>where
P:Product<Self::Item>,
[src]fnsorted(self) ->IntoIter<Self::Item>where
Self::Item:Ord,
[src]fnsorted_by<F>(self, cmp: F) ->IntoIter<Self::Item>where
F:FnMut(&Self::Item, &Self::Item) ->Ordering,
[src]fnsorted_by_key<K, F>(self, f: F) ->IntoIter<Self::Item>where
F:FnMut(&Self::Item) -> K,
K:Ord,
[src]fnpartition_map<A, B, F, L, R>(self, predicate: F) ->(A, B)where
A:Default +Extend<L>,
B:Default +Extend<R>,
F:FnMut(Self::Item) ->Either<L, R>,
[src]fninto_group_map<K, V>(self) ->HashMap<K,Vec<V>,RandomState>where
K:Hash +Eq,
Self:Iterator<Item =(K, V)>,
[src]fnminmax(self) ->MinMaxResult<Self::Item>where
Self::Item:PartialOrd<Self::Item>,
[src]fnminmax_by_key<K, F>(self, key: F) ->MinMaxResult<Self::Item>where
F:FnMut(&Self::Item) -> K,
K:PartialOrd<K>,
[src]fnminmax_by<F>(self, compare: F) ->MinMaxResult<Self::Item>where
F:FnMut(&Self::Item, &Self::Item) ->Ordering,
[src]fnexactly_one(self) ->Result<Self::Item,ExactlyOneError<Self>>
[src]impl<T> Same<T> for T
typeOutput = T
Should always beSelf
impl<T, U>TryFrom<U> for Twhere
U:Into<T>,
[src]typeError =Infallible
The type returned in the event of a conversion error.
fntry_from(value: U) ->Result<T, <T asTryFrom<U>>::Error>
[src]impl<T, U>TryInto<U> for Twhere
U:TryFrom<T>,
[src]typeError = <U asTryFrom<T>>::Error
The type returned in the event of a conversion error.
fntry_into(self) ->Result<U, <U asTryFrom<T>>::Error>
[src]impl<V, T> VZip<V> for Twhere
V: MultiLane<T>,
fnvzip(self) -> V