Movatterモバイル変換


[0]ホーム

URL:


[][src]Structrustpython_vm::pyobject::PyIterator

pub struct PyIterator<'a, T> { /* fields omitted */ }

Trait Implementations

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) ->usize1.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) ->&mutSelf1.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]

Auto Trait Implementations

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>

Blanket Implementations

impl<T>Any for Twhere
    T: 'static + ?Sized
[src]

fntype_id(&self) ->TypeId[src]

impl<T>Borrow<T> for Twhere
    T: ?Sized
[src]

fnborrow(&self) ->&T[src]

impl<T>BorrowMut<T> for Twhere
    T: ?Sized
[src]

fnborrow_mut(&mut self) ->&mutT[src]

impl<T>From<T> for T[src]

fnfrom(t: T) -> T[src]

impl<T, U>Into<U> for Twhere
    U:From<T>, 
[src]

fninto(self) -> U[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


[8]ページ先頭

©2009-2025 Movatter.jp