1.0.0[−][src]Struct tract_hir::internal::tract_downcast_rs::__std::ops::RangeFrom
A range only bounded inclusively below (start..
).
The RangeFrom
start..
contains all values with x >= start
.
Note: Overflow in the Iterator
implementation (when the contained
data type reaches its numerical limit) is allowed to panic, wrap, or
saturate. This behavior is defined by the implementation of the Step
trait. For primitive integers, this follows the normal rules, and respects
the overflow checks profile (panic in debug, wrap in release). Note also
that overflow happens earlier than you might assume: the overflow happens
in the call to next
that yields the maximum value, as the range must be
set to a state to yield the next value.
Examples
assert_eq!((2..), std::ops::RangeFrom { start: 2 }); assert_eq!(2 + 3 + 4, (2..).take(3).sum()); let arr = [0, 1, 2, 3, 4]; assert_eq!(arr[ .. ], [0,1,2,3,4]); assert_eq!(arr[ .. 3], [0,1,2 ]); assert_eq!(arr[ ..=3], [0,1,2,3 ]); assert_eq!(arr[1.. ], [ 1,2,3,4]); // RangeFrom assert_eq!(arr[1.. 3], [ 1,2 ]); assert_eq!(arr[1..=3], [ 1,2,3 ]);
Fields
start: Idx
The lower bound of the range (inclusive).
Implementations
impl<Idx> RangeFrom<Idx> where
Idx: PartialOrd<Idx>,
[src]
Idx: PartialOrd<Idx>,
pub fn contains<U>(&self, item: &U) -> bool where
Idx: PartialOrd<U>,
U: PartialOrd<Idx> + ?Sized,
1.35.0[src]
Idx: PartialOrd<U>,
U: PartialOrd<Idx> + ?Sized,
Returns true
if item
is contained in the range.
Examples
assert!(!(3..).contains(&2)); assert!( (3..).contains(&3)); assert!( (3..).contains(&1_000_000_000)); assert!( (0.0..).contains(&0.5)); assert!(!(0.0..).contains(&f32::NAN)); assert!(!(f32::NAN..).contains(&0.5));
Trait Implementations
impl<Idx> Clone for RangeFrom<Idx> where
Idx: Clone,
[src]
Idx: Clone,
impl<Idx> Debug for RangeFrom<Idx> where
Idx: Debug,
[src]
Idx: Debug,
impl<Idx> Eq for RangeFrom<Idx> where
Idx: Eq,
[src]
Idx: Eq,
impl From<RangeFrom<i32>> for SliceOrIndex
[src]
fn from(r: RangeFrom<i32>) -> SliceOrIndex
[src]
impl From<RangeFrom<i32>> for Slice
[src]
impl From<RangeFrom<isize>> for SliceOrIndex
[src]
fn from(r: RangeFrom<isize>) -> SliceOrIndex
[src]
impl From<RangeFrom<isize>> for Slice
[src]
impl From<RangeFrom<usize>> for Slice
[src]
impl From<RangeFrom<usize>> for SliceOrIndex
[src]
fn from(r: RangeFrom<usize>) -> SliceOrIndex
[src]
impl<A> FusedIterator for RangeFrom<A> where
A: Step,
1.26.0[src]
A: Step,
impl<Idx> Hash for RangeFrom<Idx> where
Idx: Hash,
[src]
Idx: Hash,
fn hash<__H>(&self, state: &mut __H) where
__H: Hasher,
[src]
__H: Hasher,
fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
impl Index<RangeFrom<usize>> for CStr
1.47.0[src]
type Output = CStr
The returned type after indexing.
fn index(&self, index: RangeFrom<usize>) -> &CStr
[src]
impl Index<RangeFrom<usize>> for String
[src]
type Output = str
The returned type after indexing.
fn index(&self, index: RangeFrom<usize>) -> &str
[src]
impl<'input, Endian> Index<RangeFrom<usize>> for EndianSlice<'input, Endian> where
Endian: Endianity,
Endian: Endianity,
type Output = [u8]
The returned type after indexing.
fn index(
&self,
idx: RangeFrom<usize>
) -> &<EndianSlice<'input, Endian> as Index<RangeFrom<usize>>>::Output
&self,
idx: RangeFrom<usize>
) -> &<EndianSlice<'input, Endian> as Index<RangeFrom<usize>>>::Output
impl<'input, Endian> Index<RangeFrom<usize>> for EndianSlice<'input, Endian> where
Endian: Endianity,
Endian: Endianity,
type Output = [u8]
The returned type after indexing.
fn index(
&self,
idx: RangeFrom<usize>
) -> &<EndianSlice<'input, Endian> as Index<RangeFrom<usize>>>::Output
&self,
idx: RangeFrom<usize>
) -> &<EndianSlice<'input, Endian> as Index<RangeFrom<usize>>>::Output
impl IndexMut<RangeFrom<usize>> for String
1.3.0[src]
impl<A> Iterator for RangeFrom<A> where
A: Step,
[src]
A: Step,
type Item = A
The type of the elements being iterated over.
fn next(&mut self) -> Option<A>
[src]
fn size_hint(&self) -> (usize, Option<usize>)
[src]
fn nth(&mut self, n: usize) -> Option<A>
[src]
fn count(self) -> usize
[src]
fn last(self) -> Option<Self::Item>
[src]
fn step_by(self, step: usize) -> StepBy<Self>ⓘ
1.28.0[src]
fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>ⓘ where
U: IntoIterator<Item = Self::Item>,
[src]
U: IntoIterator<Item = Self::Item>,
fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>ⓘ where
U: IntoIterator,
[src]
U: IntoIterator,
fn map<B, F>(self, f: F) -> Map<Self, F>ⓘ where
F: FnMut(Self::Item) -> B,
[src]
F: FnMut(Self::Item) -> B,
fn for_each<F>(self, f: F) where
F: FnMut(Self::Item),
1.21.0[src]
F: FnMut(Self::Item),
fn filter<P>(self, predicate: P) -> Filter<Self, P>ⓘ where
P: FnMut(&Self::Item) -> bool,
[src]
P: FnMut(&Self::Item) -> bool,
fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>ⓘ where
F: FnMut(Self::Item) -> Option<B>,
[src]
F: FnMut(Self::Item) -> Option<B>,
fn enumerate(self) -> Enumerate<Self>ⓘ
[src]
fn peekable(self) -> Peekable<Self>ⓘ
[src]
fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>ⓘ where
P: FnMut(&Self::Item) -> bool,
[src]
P: FnMut(&Self::Item) -> bool,
fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>ⓘ where
P: FnMut(&Self::Item) -> bool,
[src]
P: FnMut(&Self::Item) -> bool,
fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>ⓘ where
P: FnMut(Self::Item) -> Option<B>,
[src]
P: FnMut(Self::Item) -> Option<B>,
fn skip(self, n: usize) -> Skip<Self>ⓘ
[src]
fn take(self, n: usize) -> Take<Self>ⓘ
[src]
fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>ⓘ where
F: FnMut(&mut St, Self::Item) -> Option<B>,
[src]
F: FnMut(&mut St, Self::Item) -> Option<B>,
fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>ⓘ where
F: FnMut(Self::Item) -> U,
U: IntoIterator,
[src]
F: FnMut(Self::Item) -> U,
U: IntoIterator,
fn flatten(self) -> Flatten<Self>ⓘ where
Self::Item: IntoIterator,
1.29.0[src]
Self::Item: IntoIterator,
fn fuse(self) -> Fuse<Self>ⓘ
[src]
fn inspect<F>(self, f: F) -> Inspect<Self, F>ⓘ where
F: FnMut(&Self::Item),
[src]
F: FnMut(&Self::Item),
fn by_ref(&mut self) -> &mut SelfⓘNotable traits for &'_ mut R
impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;
[src]
Notable traits for &'_ mut R
impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;
#[must_use =
"if you really need to exhaust the iterator, consider `.for_each(drop)` instead"]fn collect<B>(self) -> B where
B: FromIterator<Self::Item>,
[src]
B: FromIterator<Self::Item>,
fn partition<B, F>(self, f: F) -> (B, B) where
B: Default + Extend<Self::Item>,
F: FnMut(&Self::Item) -> bool,
[src]
B: Default + Extend<Self::Item>,
F: FnMut(&Self::Item) -> bool,
fn partition_in_place<'a, T, P>(self, predicate: P) -> usize where
P: FnMut(&T) -> bool,
Self: DoubleEndedIterator<Item = &'a mut T>,
T: 'a,
[src]
P: FnMut(&T) -> bool,
Self: DoubleEndedIterator<Item = &'a mut T>,
T: 'a,
fn is_partitioned<P>(self, predicate: P) -> bool where
P: FnMut(Self::Item) -> bool,
[src]
P: FnMut(Self::Item) -> bool,
fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R where
F: FnMut(B, Self::Item) -> R,
R: Try<Ok = B>,
1.27.0[src]
F: FnMut(B, Self::Item) -> R,
R: Try<Ok = B>,
fn try_for_each<F, R>(&mut self, f: F) -> R where
F: FnMut(Self::Item) -> R,
R: Try<Ok = ()>,
1.27.0[src]
F: FnMut(Self::Item) -> R,
R: Try<Ok = ()>,
fn fold<B, F>(self, init: B, f: F) -> B where
F: FnMut(B, Self::Item) -> B,
[src]
F: FnMut(B, Self::Item) -> B,
fn fold_first<F>(self, f: F) -> Option<Self::Item> where
F: FnMut(Self::Item, Self::Item) -> Self::Item,
[src]
F: FnMut(Self::Item, Self::Item) -> Self::Item,
fn all<F>(&mut self, f: F) -> bool where
F: FnMut(Self::Item) -> bool,
[src]
F: FnMut(Self::Item) -> bool,
fn any<F>(&mut self, f: F) -> bool where
F: FnMut(Self::Item) -> bool,
[src]
F: FnMut(Self::Item) -> bool,
fn find<P>(&mut self, predicate: P) -> Option<Self::Item> where
P: FnMut(&Self::Item) -> bool,
[src]
P: FnMut(&Self::Item) -> bool,
fn find_map<B, F>(&mut self, f: F) -> Option<B> where
F: FnMut(Self::Item) -> Option<B>,
1.30.0[src]
F: FnMut(Self::Item) -> Option<B>,
fn try_find<F, R>(
&mut self,
f: F
) -> Result<Option<Self::Item>, <R as Try>::Error> where
F: FnMut(&Self::Item) -> R,
R: Try<Ok = bool>,
[src]
&mut self,
f: F
) -> Result<Option<Self::Item>, <R as Try>::Error> where
F: FnMut(&Self::Item) -> R,
R: Try<Ok = bool>,
fn position<P>(&mut self, predicate: P) -> Option<usize> where
P: FnMut(Self::Item) -> bool,
[src]
P: FnMut(Self::Item) -> bool,
fn rposition<P>(&mut self, predicate: P) -> Option<usize> where
P: FnMut(Self::Item) -> bool,
Self: ExactSizeIterator + DoubleEndedIterator,
[src]
P: FnMut(Self::Item) -> bool,
Self: ExactSizeIterator + DoubleEndedIterator,
fn max(self) -> Option<Self::Item> where
Self::Item: Ord,
[src]
Self::Item: Ord,
fn min(self) -> Option<Self::Item> where
Self::Item: Ord,
[src]
Self::Item: Ord,
fn max_by_key<B, F>(self, f: F) -> Option<Self::Item> where
B: Ord,
F: FnMut(&Self::Item) -> B,
1.6.0[src]
B: Ord,
F: FnMut(&Self::Item) -> B,
fn max_by<F>(self, compare: F) -> Option<Self::Item> where
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
1.15.0[src]
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
fn min_by_key<B, F>(self, f: F) -> Option<Self::Item> where
B: Ord,
F: FnMut(&Self::Item) -> B,
1.6.0[src]
B: Ord,
F: FnMut(&Self::Item) -> B,
fn min_by<F>(self, compare: F) -> Option<Self::Item> where
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
1.15.0[src]
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
fn rev(self) -> Rev<Self>ⓘ where
Self: DoubleEndedIterator,
[src]
Self: DoubleEndedIterator,
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
Self: Iterator<Item = (A, B)>,
[src]
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
Self: Iterator<Item = (A, B)>,
fn copied<'a, T>(self) -> Copied<Self>ⓘ where
Self: Iterator<Item = &'a T>,
T: 'a + Copy,
1.36.0[src]
Self: Iterator<Item = &'a T>,
T: 'a + Copy,
fn cloned<'a, T>(self) -> Cloned<Self>ⓘ where
Self: Iterator<Item = &'a T>,
T: 'a + Clone,
[src]
Self: Iterator<Item = &'a T>,
T: 'a + Clone,
fn cycle(self) -> Cycle<Self>ⓘ where
Self: Clone,
[src]
Self: Clone,
fn sum<S>(self) -> S where
S: Sum<Self::Item>,
1.11.0[src]
S: Sum<Self::Item>,
fn product<P>(self) -> P where
P: Product<Self::Item>,
1.11.0[src]
P: Product<Self::Item>,
fn cmp<I>(self, other: I) -> Ordering where
I: IntoIterator<Item = Self::Item>,
Self::Item: Ord,
1.5.0[src]
I: IntoIterator<Item = Self::Item>,
Self::Item: Ord,
fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering where
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
I: IntoIterator,
[src]
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
I: IntoIterator,
fn partial_cmp<I>(self, other: I) -> Option<Ordering> where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
1.5.0[src]
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering> where
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
I: IntoIterator,
[src]
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
I: IntoIterator,
fn eq<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>,
1.5.0[src]
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>,
fn eq_by<I, F>(self, other: I, eq: F) -> bool where
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
I: IntoIterator,
[src]
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
I: IntoIterator,
fn ne<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>,
1.5.0[src]
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>,
fn lt<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
1.5.0[src]
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
fn le<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
1.5.0[src]
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
fn gt<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
1.5.0[src]
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
fn ge<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
1.5.0[src]
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
fn is_sorted(self) -> bool where
Self::Item: PartialOrd<Self::Item>,
[src]
Self::Item: PartialOrd<Self::Item>,
fn is_sorted_by<F>(self, compare: F) -> bool where
F: FnMut(&Self::Item, &Self::Item) -> Option<Ordering>,
[src]
F: FnMut(&Self::Item, &Self::Item) -> Option<Ordering>,
fn is_sorted_by_key<F, K>(self, f: F) -> bool where
F: FnMut(Self::Item) -> K,
K: PartialOrd<K>,
[src]
F: FnMut(Self::Item) -> K,
K: PartialOrd<K>,
impl<Idx> PartialEq<RangeFrom<Idx>> for RangeFrom<Idx> where
Idx: PartialEq<Idx>,
[src]
Idx: PartialEq<Idx>,
impl<'_, T> RangeBounds<T> for RangeFrom<&'_ T>
1.28.0[src]
fn start_bound(&self) -> Bound<&T>
[src]
fn end_bound(&self) -> Bound<&T>
[src]
fn contains<U>(&self, item: &U) -> bool where
T: PartialOrd<U>,
U: PartialOrd<T> + ?Sized,
1.35.0[src]
T: PartialOrd<U>,
U: PartialOrd<T> + ?Sized,
impl<T> RangeBounds<T> for RangeFrom<T>
1.28.0[src]
fn start_bound(&self) -> Bound<&T>
[src]
fn end_bound(&self) -> Bound<&T>
[src]
fn contains<U>(&self, item: &U) -> bool where
T: PartialOrd<U>,
U: PartialOrd<T> + ?Sized,
1.35.0[src]
T: PartialOrd<U>,
U: PartialOrd<T> + ?Sized,
impl<T> SliceIndex<[T]> for RangeFrom<usize>
1.15.0[src]
type Output = [T]
The output type returned by methods.
fn get(self, slice: &[T]) -> Option<&[T]>
[src]
fn get_mut(self, slice: &mut [T]) -> Option<&mut [T]>
[src]
unsafe fn get_unchecked(self, slice: *const [T]) -> *const [T]
[src]
unsafe fn get_unchecked_mut(self, slice: *mut [T]) -> *mut [T]
[src]
fn index(self, slice: &[T]) -> &[T]ⓘ
[src]
fn index_mut(self, slice: &mut [T]) -> &mut [T]ⓘ
[src]
impl SliceIndex<str> for RangeFrom<usize>
1.20.0[src]
Implements substring slicing with syntax &self[begin ..]
or &mut self[begin ..]
.
Returns a slice of the given string from the byte range [begin
,
len
). Equivalent to &self[begin .. len]
or &mut self[begin .. len]
.
This operation is O(1)
.
Prior to 1.20.0, these indexing operations were still supported by
direct implementation of Index
and IndexMut
.
Panics
Panics if begin
does not point to the starting byte offset of
a character (as defined by is_char_boundary
), or if begin > len
.
type Output = str
The output type returned by methods.
fn get(
self,
slice: &str
) -> Option<&<RangeFrom<usize> as SliceIndex<str>>::Output>
[src]
self,
slice: &str
) -> Option<&<RangeFrom<usize> as SliceIndex<str>>::Output>
fn get_mut(
self,
slice: &mut str
) -> Option<&mut <RangeFrom<usize> as SliceIndex<str>>::Output>
[src]
self,
slice: &mut str
) -> Option<&mut <RangeFrom<usize> as SliceIndex<str>>::Output>
unsafe fn get_unchecked(
self,
slice: *const str
) -> *const <RangeFrom<usize> as SliceIndex<str>>::Output
[src]
self,
slice: *const str
) -> *const <RangeFrom<usize> as SliceIndex<str>>::Output
unsafe fn get_unchecked_mut(
self,
slice: *mut str
) -> *mut <RangeFrom<usize> as SliceIndex<str>>::Output
[src]
self,
slice: *mut str
) -> *mut <RangeFrom<usize> as SliceIndex<str>>::Output
fn index(self, slice: &str) -> &<RangeFrom<usize> as SliceIndex<str>>::Outputⓘ
[src]
fn index_mut(
self,
slice: &mut str
) -> &mut <RangeFrom<usize> as SliceIndex<str>>::Outputⓘ
[src]
self,
slice: &mut str
) -> &mut <RangeFrom<usize> as SliceIndex<str>>::Outputⓘ
Auto Trait Implementations
impl<Idx> RefUnwindSafe for RangeFrom<Idx> where
Idx: RefUnwindSafe,
Idx: RefUnwindSafe,
impl<Idx> Send for RangeFrom<Idx> where
Idx: Send,
Idx: Send,
impl<Idx> Sync for RangeFrom<Idx> where
Idx: Sync,
Idx: Sync,
impl<Idx> Unpin for RangeFrom<Idx> where
Idx: Unpin,
Idx: Unpin,
impl<Idx> UnwindSafe for RangeFrom<Idx> where
Idx: UnwindSafe,
Idx: UnwindSafe,
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
fn borrow(&self) -> &TⓘNotable traits for &'_ mut R
impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;
[src]
Notable traits for &'_ mut R
impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
fn borrow_mut(&mut self) -> &mut TⓘNotable traits for &'_ mut R
impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;
[src]
Notable traits for &'_ mut R
impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;
impl<T> Downcast for T where
T: Any,
T: Any,
fn into_any(self: Box<T>) -> Box<dyn Any + 'static>ⓘNotable traits for Box<R>
impl<R> Read for Box<R> where
R: Read + ?Sized, impl<W> Write for Box<W> where
W: Write + ?Sized, impl<F> Future for Box<F> where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;impl<I> Iterator for Box<I> where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;
Notable traits for Box<R>
impl<R> Read for Box<R> where
R: Read + ?Sized, impl<W> Write for Box<W> where
W: Write + ?Sized, impl<F> Future for Box<F> where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;impl<I> Iterator for Box<I> where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;
fn into_any_rc(self: Rc<T>) -> Rc<dyn Any + 'static>
fn as_any(&self) -> &(dyn Any + 'static)
fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
impl<T> DowncastSync for T where
T: Send + Sync + Any,
T: Send + Sync + Any,
impl<T> DynClone for T where
T: Clone,
[src]
T: Clone,
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<I> IntoIterator for I where
I: Iterator,
[src]
I: Iterator,
type Item = <I as Iterator>::Item
The type of the elements being iterated over.
type IntoIter = I
Which kind of iterator are we turning this into?
fn into_iter(self) -> I
[src]
impl<T> Itertools for T where
T: Iterator + ?Sized,
[src]
T: Iterator + ?Sized,
fn interleave<J>(
self,
other: J
) -> Interleave<Self, <J as IntoIterator>::IntoIter>ⓘNotable traits for Interleave<I, J>
impl<I, J> Iterator for Interleave<I, J> where
I: Iterator,
J: Iterator<Item = <I as Iterator>::Item>, type Item = <I as Iterator>::Item;
where
J: IntoIterator<Item = Self::Item>,
[src]
self,
other: J
) -> Interleave<Self, <J as IntoIterator>::IntoIter>ⓘ
Notable traits for Interleave<I, J>
impl<I, J> Iterator for Interleave<I, J> where
I: Iterator,
J: Iterator<Item = <I as Iterator>::Item>, type Item = <I as Iterator>::Item;
J: IntoIterator<Item = Self::Item>,
fn interleave_shortest<J>(
self,
other: J
) -> InterleaveShortest<Self, <J as IntoIterator>::IntoIter>ⓘNotable traits for InterleaveShortest<I, J>
impl<I, J> Iterator for InterleaveShortest<I, J> where
I: Iterator,
J: Iterator<Item = <I as Iterator>::Item>, type Item = <I as Iterator>::Item;
where
J: IntoIterator<Item = Self::Item>,
[src]
self,
other: J
) -> InterleaveShortest<Self, <J as IntoIterator>::IntoIter>ⓘ
Notable traits for InterleaveShortest<I, J>
impl<I, J> Iterator for InterleaveShortest<I, J> where
I: Iterator,
J: Iterator<Item = <I as Iterator>::Item>, type Item = <I as Iterator>::Item;
J: IntoIterator<Item = Self::Item>,
fn intersperse(self, element: Self::Item) -> Intersperse<Self>ⓘNotable traits for Intersperse<I>
impl<I> Iterator for Intersperse<I> where
I: Iterator,
<I as Iterator>::Item: Clone, type Item = <I as Iterator>::Item;
where
Self::Item: Clone,
[src]
Notable traits for Intersperse<I>
impl<I> Iterator for Intersperse<I> where
I: Iterator,
<I as Iterator>::Item: Clone, type Item = <I as Iterator>::Item;
Self::Item: Clone,
fn zip_longest<J>(
self,
other: J
) -> ZipLongest<Self, <J as IntoIterator>::IntoIter>ⓘNotable traits for ZipLongest<T, U>
impl<T, U> Iterator for ZipLongest<T, U> where
T: Iterator,
U: Iterator, type Item = EitherOrBoth<<T as Iterator>::Item, <U as Iterator>::Item>;
where
J: IntoIterator,
[src]
self,
other: J
) -> ZipLongest<Self, <J as IntoIterator>::IntoIter>ⓘ
Notable traits for ZipLongest<T, U>
impl<T, U> Iterator for ZipLongest<T, U> where
T: Iterator,
U: Iterator, type Item = EitherOrBoth<<T as Iterator>::Item, <U as Iterator>::Item>;
J: IntoIterator,
fn zip_eq<J>(self, other: J) -> ZipEq<Self, <J as IntoIterator>::IntoIter>ⓘ where
J: IntoIterator,
[src]
J: IntoIterator,
fn batching<B, F>(self, f: F) -> Batching<Self, F>ⓘ where
F: FnMut(&mut Self) -> Option<B>,
[src]
F: FnMut(&mut Self) -> Option<B>,
fn group_by<K, F>(self, key: F) -> GroupBy<K, Self, F> where
F: FnMut(&Self::Item) -> K,
K: PartialEq<K>,
[src]
F: FnMut(&Self::Item) -> K,
K: PartialEq<K>,
fn chunks(self, size: usize) -> IntoChunks<Self>
[src]
fn tuple_windows<T>(self) -> TupleWindows<Self, T>ⓘNotable traits for TupleWindows<I, T>
impl<I, T> Iterator for TupleWindows<I, T> where
I: Iterator<Item = <T as TupleCollect>::Item>,
T: HomogeneousTuple + Clone,
<T as TupleCollect>::Item: Clone, type Item = T;
where
Self: Iterator<Item = <T as TupleCollect>::Item>,
T: HomogeneousTuple,
<T as TupleCollect>::Item: Clone,
[src]
Notable traits for TupleWindows<I, T>
impl<I, T> Iterator for TupleWindows<I, T> where
I: Iterator<Item = <T as TupleCollect>::Item>,
T: HomogeneousTuple + Clone,
<T as TupleCollect>::Item: Clone, type Item = T;
Self: Iterator<Item = <T as TupleCollect>::Item>,
T: HomogeneousTuple,
<T as TupleCollect>::Item: Clone,
fn tuples<T>(self) -> Tuples<Self, T>ⓘ where
Self: Iterator<Item = <T as TupleCollect>::Item>,
T: HomogeneousTuple,
[src]
Self: Iterator<Item = <T as TupleCollect>::Item>,
T: HomogeneousTuple,
fn tee(self) -> (Tee<Self>, Tee<Self>) where
Self::Item: Clone,
[src]
Self::Item: Clone,
fn step(self, n: usize) -> Step<Self>ⓘ
[src]
fn map_into<R>(self) -> MapInto<Self, R>ⓘ where
Self::Item: Into<R>,
[src]
Self::Item: Into<R>,
fn map_results<F, T, U, E>(self, f: F) -> MapResults<Self, F>ⓘNotable traits for MapResults<I, F>
impl<I, F, T, U, E> Iterator for MapResults<I, F> where
F: FnMut(T) -> U,
I: Iterator<Item = Result<T, E>>, type Item = Result<U, E>;
where
F: FnMut(T) -> U,
Self: Iterator<Item = Result<T, E>>,
[src]
Notable traits for MapResults<I, F>
impl<I, F, T, U, E> Iterator for MapResults<I, F> where
F: FnMut(T) -> U,
I: Iterator<Item = Result<T, E>>, type Item = Result<U, E>;
F: FnMut(T) -> U,
Self: Iterator<Item = Result<T, E>>,
fn merge<J>(
self,
other: J
) -> MergeBy<Self, <J as IntoIterator>::IntoIter, MergeLte>ⓘ where
J: IntoIterator<Item = Self::Item>,
Self::Item: PartialOrd<Self::Item>,
[src]
self,
other: J
) -> MergeBy<Self, <J as IntoIterator>::IntoIter, MergeLte>ⓘ where
J: IntoIterator<Item = Self::Item>,
Self::Item: PartialOrd<Self::Item>,
fn merge_by<J, F>(
self,
other: J,
is_first: F
) -> MergeBy<Self, <J as IntoIterator>::IntoIter, F>ⓘ where
F: FnMut(&Self::Item, &Self::Item) -> bool,
J: IntoIterator<Item = Self::Item>,
[src]
self,
other: J,
is_first: F
) -> MergeBy<Self, <J as IntoIterator>::IntoIter, F>ⓘ where
F: FnMut(&Self::Item, &Self::Item) -> bool,
J: IntoIterator<Item = Self::Item>,
fn merge_join_by<J, F>(
self,
other: J,
cmp_fn: F
) -> MergeJoinBy<Self, <J as IntoIterator>::IntoIter, F>ⓘ where
F: FnMut(&Self::Item, &<J as IntoIterator>::Item) -> Ordering,
J: IntoIterator,
[src]
self,
other: J,
cmp_fn: F
) -> MergeJoinBy<Self, <J as IntoIterator>::IntoIter, F>ⓘ where
F: FnMut(&Self::Item, &<J as IntoIterator>::Item) -> Ordering,
J: IntoIterator,
fn kmerge(self) -> KMergeBy<<Self::Item as IntoIterator>::IntoIter, KMergeByLt>ⓘ where
Self::Item: IntoIterator,
<Self::Item as IntoIterator>::Item: PartialOrd<<Self::Item as IntoIterator>::Item>,
[src]
Self::Item: IntoIterator,
<Self::Item as IntoIterator>::Item: PartialOrd<<Self::Item as IntoIterator>::Item>,
fn kmerge_by<F>(
self,
first: F
) -> KMergeBy<<Self::Item as IntoIterator>::IntoIter, F>ⓘ where
F: FnMut(&<Self::Item as IntoIterator>::Item, &<Self::Item as IntoIterator>::Item) -> bool,
Self::Item: IntoIterator,
[src]
self,
first: F
) -> KMergeBy<<Self::Item as IntoIterator>::IntoIter, F>ⓘ where
F: FnMut(&<Self::Item as IntoIterator>::Item, &<Self::Item as IntoIterator>::Item) -> bool,
Self::Item: IntoIterator,
fn cartesian_product<J>(
self,
other: J
) -> Product<Self, <J as IntoIterator>::IntoIter>ⓘ where
J: IntoIterator,
Self::Item: Clone,
<J as IntoIterator>::IntoIter: Clone,
[src]
self,
other: J
) -> Product<Self, <J as IntoIterator>::IntoIter>ⓘ where
J: IntoIterator,
Self::Item: Clone,
<J as IntoIterator>::IntoIter: Clone,
fn multi_cartesian_product(
self
) -> MultiProduct<<Self::Item as IntoIterator>::IntoIter>ⓘ where
Self: Iterator,
Self::Item: IntoIterator,
<Self::Item as IntoIterator>::IntoIter: Clone,
<Self::Item as IntoIterator>::Item: Clone,
[src]
self
) -> MultiProduct<<Self::Item as IntoIterator>::IntoIter>ⓘ where
Self: Iterator,
Self::Item: IntoIterator,
<Self::Item as IntoIterator>::IntoIter: Clone,
<Self::Item as IntoIterator>::Item: Clone,
fn coalesce<F>(self, f: F) -> Coalesce<Self, F>ⓘ where
F: FnMut(Self::Item, Self::Item) -> Result<Self::Item, (Self::Item, Self::Item)>,
[src]
F: FnMut(Self::Item, Self::Item) -> Result<Self::Item, (Self::Item, Self::Item)>,
fn dedup(self) -> DedupBy<Self, DedupEq>ⓘ where
Self::Item: PartialEq<Self::Item>,
[src]
Self::Item: PartialEq<Self::Item>,
fn dedup_by<Cmp>(self, cmp: Cmp) -> DedupBy<Self, Cmp>ⓘ where
Cmp: FnMut(&Self::Item, &Self::Item) -> bool,
[src]
Cmp: FnMut(&Self::Item, &Self::Item) -> bool,
fn unique(self) -> Unique<Self>ⓘ where
Self::Item: Clone,
Self::Item: Eq,
Self::Item: Hash,
[src]
Self::Item: Clone,
Self::Item: Eq,
Self::Item: Hash,
fn unique_by<V, F>(self, f: F) -> UniqueBy<Self, V, F>ⓘ where
F: FnMut(&Self::Item) -> V,
V: Eq + Hash,
[src]
F: FnMut(&Self::Item) -> V,
V: Eq + Hash,
fn peeking_take_while<F>(&mut self, accept: F) -> PeekingTakeWhile<'_, Self, F>ⓘNotable traits for PeekingTakeWhile<'a, I, F>
impl<'a, I, F> Iterator for PeekingTakeWhile<'a, I, F> where
F: FnMut(&<I as Iterator>::Item) -> bool,
I: PeekingNext, type Item = <I as Iterator>::Item;
where
F: FnMut(&Self::Item) -> bool,
Self: PeekingNext,
[src]
Notable traits for PeekingTakeWhile<'a, I, F>
impl<'a, I, F> Iterator for PeekingTakeWhile<'a, I, F> where
F: FnMut(&<I as Iterator>::Item) -> bool,
I: PeekingNext, type Item = <I as Iterator>::Item;
F: FnMut(&Self::Item) -> bool,
Self: PeekingNext,
fn take_while_ref<F>(&mut self, accept: F) -> TakeWhileRef<'_, Self, F>ⓘ where
F: FnMut(&Self::Item) -> bool,
Self: Clone,
[src]
F: FnMut(&Self::Item) -> bool,
Self: Clone,
fn while_some<A>(self) -> WhileSome<Self>ⓘ where
Self: Iterator<Item = Option<A>>,
[src]
Self: Iterator<Item = Option<A>>,
fn tuple_combinations<T>(self) -> TupleCombinations<Self, T>ⓘNotable traits for TupleCombinations<I, T>
impl<I, T> Iterator for TupleCombinations<I, T> where
I: Iterator,
T: HasCombination<I>, type Item = T;
where
Self: Clone,
T: HasCombination<Self>,
Self::Item: Clone,
[src]
Notable traits for TupleCombinations<I, T>
impl<I, T> Iterator for TupleCombinations<I, T> where
I: Iterator,
T: HasCombination<I>, type Item = T;
Self: Clone,
T: HasCombination<Self>,
Self::Item: Clone,
fn combinations(self, k: usize) -> Combinations<Self>ⓘ where
Self::Item: Clone,
[src]
Self::Item: Clone,
fn combinations_with_replacement(
self,
k: usize
) -> CombinationsWithReplacement<Self>ⓘ where
Self::Item: Clone,
[src]
self,
k: usize
) -> CombinationsWithReplacement<Self>ⓘ where
Self::Item: Clone,
fn permutations(self, k: usize) -> Permutations<Self>ⓘ where
Self::Item: Clone,
[src]
Self::Item: Clone,
fn pad_using<F>(self, min: usize, f: F) -> PadUsing<Self, F>ⓘ where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn with_position(self) -> WithPosition<Self>ⓘNotable traits for WithPosition<I>
impl<I> Iterator for WithPosition<I> where
I: Iterator, type Item = Position<<I as Iterator>::Item>;
[src]
Notable traits for WithPosition<I>
impl<I> Iterator for WithPosition<I> where
I: Iterator, type Item = Position<<I as Iterator>::Item>;
fn positions<P>(self, predicate: P) -> Positions<Self, P>ⓘ where
P: FnMut(Self::Item) -> bool,
[src]
P: FnMut(Self::Item) -> bool,
fn update<F>(self, updater: F) -> Update<Self, F>ⓘ where
F: FnMut(&mut Self::Item),
[src]
F: FnMut(&mut Self::Item),
fn next_tuple<T>(&mut self) -> Option<T> where
Self: Iterator<Item = <T as TupleCollect>::Item>,
T: HomogeneousTuple,
[src]
Self: Iterator<Item = <T as TupleCollect>::Item>,
T: HomogeneousTuple,
fn collect_tuple<T>(self) -> Option<T> where
Self: Iterator<Item = <T as TupleCollect>::Item>,
T: HomogeneousTuple,
[src]
Self: Iterator<Item = <T as TupleCollect>::Item>,
T: HomogeneousTuple,
fn find_position<P>(&mut self, pred: P) -> Option<(usize, Self::Item)> where
P: FnMut(&Self::Item) -> bool,
[src]
P: FnMut(&Self::Item) -> bool,
fn all_equal(&mut self) -> bool where
Self::Item: PartialEq<Self::Item>,
[src]
Self::Item: PartialEq<Self::Item>,
fn dropping(self, n: usize) -> Self
[src]
fn dropping_back(self, n: usize) -> Self where
Self: DoubleEndedIterator,
[src]
Self: DoubleEndedIterator,
fn foreach<F>(self, f: F) where
F: FnMut(Self::Item),
[src]
F: FnMut(Self::Item),
fn concat(self) -> Self::Item where
Self::Item: Extend<<Self::Item as IntoIterator>::Item>,
Self::Item: IntoIterator,
Self::Item: Default,
[src]
Self::Item: Extend<<Self::Item as IntoIterator>::Item>,
Self::Item: IntoIterator,
Self::Item: Default,
fn collect_vec(self) -> Vec<Self::Item>ⓘ
[src]
fn try_collect<T, U, E>(self) -> Result<U, E> where
Self: Iterator<Item = Result<T, E>>,
Result<U, E>: FromIterator<Result<T, E>>,
[src]
Self: Iterator<Item = Result<T, E>>,
Result<U, E>: FromIterator<Result<T, E>>,
fn set_from<'a, A, J>(&mut self, from: J) -> usize where
A: 'a,
J: IntoIterator<Item = A>,
Self: Iterator<Item = &'a mut A>,
[src]
A: 'a,
J: IntoIterator<Item = A>,
Self: Iterator<Item = &'a mut A>,
fn join(&mut self, sep: &str) -> String where
Self::Item: Display,
[src]
Self::Item: Display,
fn format(self, sep: &str) -> Format<'_, Self>
[src]
fn format_with<F>(self, sep: &str, format: F) -> FormatWith<'_, Self, F> where
F: FnMut(Self::Item, &mut dyn FnMut(&dyn Display)) -> Result<(), Error>,
[src]
F: FnMut(Self::Item, &mut dyn FnMut(&dyn Display)) -> Result<(), Error>,
fn fold_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]
F: FnMut(B, A) -> B,
Self: Iterator<Item = Result<A, E>>,
fn fold_options<A, B, F>(&mut self, start: B, f: F) -> Option<B> where
F: FnMut(B, A) -> B,
Self: Iterator<Item = Option<A>>,
[src]
F: FnMut(B, A) -> B,
Self: Iterator<Item = Option<A>>,
fn fold1<F>(self, f: F) -> Option<Self::Item> where
F: FnMut(Self::Item, Self::Item) -> Self::Item,
[src]
F: FnMut(Self::Item, Self::Item) -> Self::Item,
fn tree_fold1<F>(self, f: F) -> Option<Self::Item> where
F: FnMut(Self::Item, Self::Item) -> Self::Item,
[src]
F: FnMut(Self::Item, Self::Item) -> Self::Item,
fn fold_while<B, F>(&mut self, init: B, f: F) -> FoldWhile<B> where
F: FnMut(B, Self::Item) -> FoldWhile<B>,
[src]
F: FnMut(B, Self::Item) -> FoldWhile<B>,
fn sum1<S>(self) -> Option<S> where
S: Sum<Self::Item>,
[src]
S: Sum<Self::Item>,
fn product1<P>(self) -> Option<P> where
P: Product<Self::Item>,
[src]
P: Product<Self::Item>,
fn sorted(self) -> IntoIter<Self::Item>ⓘ where
Self::Item: Ord,
[src]
Self::Item: Ord,
fn sorted_by<F>(self, cmp: F) -> IntoIter<Self::Item>ⓘ where
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
[src]
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
fn sorted_by_key<K, F>(self, f: F) -> IntoIter<Self::Item>ⓘ where
F: FnMut(&Self::Item) -> K,
K: Ord,
[src]
F: FnMut(&Self::Item) -> K,
K: Ord,
fn partition_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]
A: Default + Extend<L>,
B: Default + Extend<R>,
F: FnMut(Self::Item) -> Either<L, R>,
fn into_group_map<K, V>(self) -> HashMap<K, Vec<V>, RandomState> where
K: Hash + Eq,
Self: Iterator<Item = (K, V)>,
[src]
K: Hash + Eq,
Self: Iterator<Item = (K, V)>,
fn minmax(self) -> MinMaxResult<Self::Item> where
Self::Item: PartialOrd<Self::Item>,
[src]
Self::Item: PartialOrd<Self::Item>,
fn minmax_by_key<K, F>(self, key: F) -> MinMaxResult<Self::Item> where
F: FnMut(&Self::Item) -> K,
K: PartialOrd<K>,
[src]
F: FnMut(&Self::Item) -> K,
K: PartialOrd<K>,
fn minmax_by<F>(self, compare: F) -> MinMaxResult<Self::Item> where
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
[src]
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
fn position_max(self) -> Option<usize> where
Self::Item: Ord,
[src]
Self::Item: Ord,
fn position_max_by_key<K, F>(self, key: F) -> Option<usize> where
F: FnMut(&Self::Item) -> K,
K: Ord,
[src]
F: FnMut(&Self::Item) -> K,
K: Ord,
fn position_max_by<F>(self, compare: F) -> Option<usize> where
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
[src]
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
fn position_min(self) -> Option<usize> where
Self::Item: Ord,
[src]
Self::Item: Ord,
fn position_min_by_key<K, F>(self, key: F) -> Option<usize> where
F: FnMut(&Self::Item) -> K,
K: Ord,
[src]
F: FnMut(&Self::Item) -> K,
K: Ord,
fn position_min_by<F>(self, compare: F) -> Option<usize> where
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
[src]
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
fn position_minmax(self) -> MinMaxResult<usize> where
Self::Item: PartialOrd<Self::Item>,
[src]
Self::Item: PartialOrd<Self::Item>,
fn position_minmax_by_key<K, F>(self, key: F) -> MinMaxResult<usize> where
F: FnMut(&Self::Item) -> K,
K: PartialOrd<K>,
[src]
F: FnMut(&Self::Item) -> K,
K: PartialOrd<K>,
fn position_minmax_by<F>(self, compare: F) -> MinMaxResult<usize> where
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
[src]
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
fn exactly_one(self) -> Result<Self::Item, ExactlyOneError<Self>>
[src]
impl<T> Itertools for T where
T: Iterator + ?Sized,
[src]
T: Iterator + ?Sized,
fn interleave<J>(
self,
other: J
) -> Interleave<Self, <J as IntoIterator>::IntoIter>ⓘNotable traits for Interleave<I, J>
impl<I, J> Iterator for Interleave<I, J> where
I: Iterator,
J: Iterator<Item = <I as Iterator>::Item>, type Item = <I as Iterator>::Item;
where
J: IntoIterator<Item = Self::Item>,
[src]
self,
other: J
) -> Interleave<Self, <J as IntoIterator>::IntoIter>ⓘ
Notable traits for Interleave<I, J>
impl<I, J> Iterator for Interleave<I, J> where
I: Iterator,
J: Iterator<Item = <I as Iterator>::Item>, type Item = <I as Iterator>::Item;
J: IntoIterator<Item = Self::Item>,
fn interleave_shortest<J>(
self,
other: J
) -> InterleaveShortest<Self, <J as IntoIterator>::IntoIter>ⓘNotable traits for InterleaveShortest<I, J>
impl<I, J> Iterator for InterleaveShortest<I, J> where
I: Iterator,
J: Iterator<Item = <I as Iterator>::Item>, type Item = <I as Iterator>::Item;
where
J: IntoIterator<Item = Self::Item>,
[src]
self,
other: J
) -> InterleaveShortest<Self, <J as IntoIterator>::IntoIter>ⓘ
Notable traits for InterleaveShortest<I, J>
impl<I, J> Iterator for InterleaveShortest<I, J> where
I: Iterator,
J: Iterator<Item = <I as Iterator>::Item>, type Item = <I as Iterator>::Item;
J: IntoIterator<Item = Self::Item>,
fn intersperse(self, element: Self::Item) -> Intersperse<Self>ⓘNotable traits for Intersperse<I>
impl<I> Iterator for Intersperse<I> where
I: Iterator,
<I as Iterator>::Item: Clone, type Item = <I as Iterator>::Item;
where
Self::Item: Clone,
[src]
Notable traits for Intersperse<I>
impl<I> Iterator for Intersperse<I> where
I: Iterator,
<I as Iterator>::Item: Clone, type Item = <I as Iterator>::Item;
Self::Item: Clone,
fn zip_longest<J>(
self,
other: J
) -> ZipLongest<Self, <J as IntoIterator>::IntoIter>ⓘNotable traits for ZipLongest<T, U>
impl<T, U> Iterator for ZipLongest<T, U> where
T: Iterator,
U: Iterator, type Item = EitherOrBoth<<T as Iterator>::Item, <U as Iterator>::Item>;
where
J: IntoIterator,
[src]
self,
other: J
) -> ZipLongest<Self, <J as IntoIterator>::IntoIter>ⓘ
Notable traits for ZipLongest<T, U>
impl<T, U> Iterator for ZipLongest<T, U> where
T: Iterator,
U: Iterator, type Item = EitherOrBoth<<T as Iterator>::Item, <U as Iterator>::Item>;
J: IntoIterator,
fn zip_eq<J>(self, other: J) -> ZipEq<Self, <J as IntoIterator>::IntoIter>ⓘ where
J: IntoIterator,
[src]
J: IntoIterator,
fn batching<B, F>(self, f: F) -> Batching<Self, F>ⓘ where
F: FnMut(&mut Self) -> Option<B>,
[src]
F: FnMut(&mut Self) -> Option<B>,
fn tuple_windows<T>(self) -> TupleWindows<Self, T>ⓘNotable traits for TupleWindows<I, T>
impl<I, T> Iterator for TupleWindows<I, T> where
I: Iterator<Item = <T as TupleCollect>::Item>,
T: TupleCollect + Clone,
<T as TupleCollect>::Item: Clone, type Item = T;
where
Self: Iterator<Item = <T as TupleCollect>::Item>,
T: TupleCollect,
<T as TupleCollect>::Item: Clone,
[src]
Notable traits for TupleWindows<I, T>
impl<I, T> Iterator for TupleWindows<I, T> where
I: Iterator<Item = <T as TupleCollect>::Item>,
T: TupleCollect + Clone,
<T as TupleCollect>::Item: Clone, type Item = T;
Self: Iterator<Item = <T as TupleCollect>::Item>,
T: TupleCollect,
<T as TupleCollect>::Item: Clone,
fn tuples<T>(self) -> Tuples<Self, T>ⓘ where
Self: Iterator<Item = <T as TupleCollect>::Item>,
T: TupleCollect,
[src]
Self: Iterator<Item = <T as TupleCollect>::Item>,
T: TupleCollect,
fn step(self, n: usize) -> Step<Self>ⓘ
[src]
fn map_into<R>(self) -> MapInto<Self, R>ⓘ where
Self::Item: Into<R>,
[src]
Self::Item: Into<R>,
fn map_results<F, T, U, E>(self, f: F) -> MapResults<Self, F>ⓘNotable traits for MapResults<I, F>
impl<I, F, T, U, E> Iterator for MapResults<I, F> where
F: FnMut(T) -> U,
I: Iterator<Item = Result<T, E>>, type Item = Result<U, E>;
where
F: FnMut(T) -> U,
Self: Iterator<Item = Result<T, E>>,
[src]
Notable traits for MapResults<I, F>
impl<I, F, T, U, E> Iterator for MapResults<I, F> where
F: FnMut(T) -> U,
I: Iterator<Item = Result<T, E>>, type Item = Result<U, E>;
F: FnMut(T) -> U,
Self: Iterator<Item = Result<T, E>>,
fn merge<J>(
self,
other: J
) -> MergeBy<Self, <J as IntoIterator>::IntoIter, MergeLte>ⓘ where
J: IntoIterator<Item = Self::Item>,
Self::Item: PartialOrd<Self::Item>,
[src]
self,
other: J
) -> MergeBy<Self, <J as IntoIterator>::IntoIter, MergeLte>ⓘ where
J: IntoIterator<Item = Self::Item>,
Self::Item: PartialOrd<Self::Item>,
fn merge_by<J, F>(
self,
other: J,
is_first: F
) -> MergeBy<Self, <J as IntoIterator>::IntoIter, F>ⓘ where
F: FnMut(&Self::Item, &Self::Item) -> bool,
J: IntoIterator<Item = Self::Item>,
[src]
self,
other: J,
is_first: F
) -> MergeBy<Self, <J as IntoIterator>::IntoIter, F>ⓘ where
F: FnMut(&Self::Item, &Self::Item) -> bool,
J: IntoIterator<Item = Self::Item>,
fn merge_join_by<J, F>(
self,
other: J,
cmp_fn: F
) -> MergeJoinBy<Self, <J as IntoIterator>::IntoIter, F>ⓘ where
F: FnMut(&Self::Item, &<J as IntoIterator>::Item) -> Ordering,
J: IntoIterator,
[src]
self,
other: J,
cmp_fn: F
) -> MergeJoinBy<Self, <J as IntoIterator>::IntoIter, F>ⓘ where
F: FnMut(&Self::Item, &<J as IntoIterator>::Item) -> Ordering,
J: IntoIterator,
fn cartesian_product<J>(
self,
other: J
) -> Product<Self, <J as IntoIterator>::IntoIter>ⓘ where
J: IntoIterator,
Self::Item: Clone,
<J as IntoIterator>::IntoIter: Clone,
[src]
self,
other: J
) -> Product<Self, <J as IntoIterator>::IntoIter>ⓘ where
J: IntoIterator,
Self::Item: Clone,
<J as IntoIterator>::IntoIter: Clone,
fn coalesce<F>(self, f: F) -> Coalesce<Self, F>ⓘ where
F: FnMut(Self::Item, Self::Item) -> Result<Self::Item, (Self::Item, Self::Item)>,
[src]
F: FnMut(Self::Item, Self::Item) -> Result<Self::Item, (Self::Item, Self::Item)>,
fn dedup(self) -> DedupBy<Self, DedupEq>ⓘ where
Self::Item: PartialEq<Self::Item>,
[src]
Self::Item: PartialEq<Self::Item>,
fn dedup_by<Cmp>(self, cmp: Cmp) -> DedupBy<Self, Cmp>ⓘ where
Cmp: FnMut(&Self::Item, &Self::Item) -> bool,
[src]
Cmp: FnMut(&Self::Item, &Self::Item) -> bool,
fn peeking_take_while<F>(&mut self, accept: F) -> PeekingTakeWhile<'_, Self, F>ⓘNotable traits for PeekingTakeWhile<'a, I, F>
impl<'a, I, F> Iterator for PeekingTakeWhile<'a, I, F> where
F: FnMut(&<I as Iterator>::Item) -> bool,
I: PeekingNext, type Item = <I as Iterator>::Item;
where
F: FnMut(&Self::Item) -> bool,
Self: PeekingNext,
[src]
Notable traits for PeekingTakeWhile<'a, I, F>
impl<'a, I, F> Iterator for PeekingTakeWhile<'a, I, F> where
F: FnMut(&<I as Iterator>::Item) -> bool,
I: PeekingNext, type Item = <I as Iterator>::Item;
F: FnMut(&Self::Item) -> bool,
Self: PeekingNext,
fn take_while_ref<F>(&mut self, accept: F) -> TakeWhileRef<'_, Self, F>ⓘ where
F: FnMut(&Self::Item) -> bool,
Self: Clone,
[src]
F: FnMut(&Self::Item) -> bool,
Self: Clone,
fn while_some<A>(self) -> WhileSome<Self>ⓘ where
Self: Iterator<Item = Option<A>>,
[src]
Self: Iterator<Item = Option<A>>,
fn tuple_combinations<T>(self) -> TupleCombinations<Self, T>ⓘNotable traits for TupleCombinations<I, T>
impl<I, T> Iterator for TupleCombinations<I, T> where
I: Iterator,
T: HasCombination<I>, type Item = T;
where
Self: Clone,
T: HasCombination<Self>,
Self::Item: Clone,
[src]
Notable traits for TupleCombinations<I, T>
impl<I, T> Iterator for TupleCombinations<I, T> where
I: Iterator,
T: HasCombination<I>, type Item = T;
Self: Clone,
T: HasCombination<Self>,
Self::Item: Clone,
fn pad_using<F>(self, min: usize, f: F) -> PadUsing<Self, F>ⓘ where
F: FnMut(usize) -> Self::Item,
[src]
F: FnMut(usize) -> Self::Item,
fn with_position(self) -> WithPosition<Self>ⓘNotable traits for WithPosition<I>
impl<I> Iterator for WithPosition<I> where
I: Iterator, type Item = Position<<I as Iterator>::Item>;
[src]
Notable traits for WithPosition<I>
impl<I> Iterator for WithPosition<I> where
I: Iterator, type Item = Position<<I as Iterator>::Item>;
fn positions<P>(self, predicate: P) -> Positions<Self, P>ⓘ where
P: FnMut(Self::Item) -> bool,
[src]
P: FnMut(Self::Item) -> bool,
fn update<F>(self, updater: F) -> Update<Self, F>ⓘ where
F: FnMut(&mut Self::Item),
[src]
F: FnMut(&mut Self::Item),
fn next_tuple<T>(&mut self) -> Option<T> where
Self: Iterator<Item = <T as TupleCollect>::Item>,
T: TupleCollect,
[src]
Self: Iterator<Item = <T as TupleCollect>::Item>,
T: TupleCollect,
fn collect_tuple<T>(self) -> Option<T> where
Self: Iterator<Item = <T as TupleCollect>::Item>,
T: TupleCollect,
[src]
Self: Iterator<Item = <T as TupleCollect>::Item>,
T: TupleCollect,
fn find_position<P>(&mut self, pred: P) -> Option<(usize, Self::Item)> where
P: FnMut(&Self::Item) -> bool,
[src]
P: FnMut(&Self::Item) -> bool,
fn all_equal(&mut self) -> bool where
Self::Item: PartialEq<Self::Item>,
[src]
Self::Item: PartialEq<Self::Item>,
fn dropping(self, n: usize) -> Self
[src]
fn dropping_back(self, n: usize) -> Self where
Self: DoubleEndedIterator,
[src]
Self: DoubleEndedIterator,
fn foreach<F>(self, f: F) where
F: FnMut(Self::Item),
[src]
F: FnMut(Self::Item),
fn concat(self) -> Self::Item where
Self::Item: Extend<<Self::Item as IntoIterator>::Item>,
Self::Item: IntoIterator,
Self::Item: Default,
[src]
Self::Item: Extend<<Self::Item as IntoIterator>::Item>,
Self::Item: IntoIterator,
Self::Item: Default,
fn set_from<'a, A, J>(&mut self, from: J) -> usize where
A: 'a,
J: IntoIterator<Item = A>,
Self: Iterator<Item = &'a mut A>,
[src]
A: 'a,
J: IntoIterator<Item = A>,
Self: Iterator<Item = &'a mut A>,
fn format(self, sep: &str) -> Format<'_, Self>
[src]
fn format_with<F>(self, sep: &str, format: F) -> FormatWith<'_, Self, F> where
F: FnMut(Self::Item, &mut dyn FnMut(&dyn Display)) -> Result<(), Error>,
[src]
F: FnMut(Self::Item, &mut dyn FnMut(&dyn Display)) -> Result<(), Error>,
fn fold_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]
F: FnMut(B, A) -> B,
Self: Iterator<Item = Result<A, E>>,
fn fold_options<A, B, F>(&mut self, start: B, f: F) -> Option<B> where
F: FnMut(B, A) -> B,
Self: Iterator<Item = Option<A>>,
[src]
F: FnMut(B, A) -> B,
Self: Iterator<Item = Option<A>>,
fn fold1<F>(self, f: F) -> Option<Self::Item> where
F: FnMut(Self::Item, Self::Item) -> Self::Item,
[src]
F: FnMut(Self::Item, Self::Item) -> Self::Item,
fn tree_fold1<F>(self, f: F) -> Option<Self::Item> where
F: FnMut(Self::Item, Self::Item) -> Self::Item,
[src]
F: FnMut(Self::Item, Self::Item) -> Self::Item,
fn fold_while<B, F>(&mut self, init: B, f: F) -> FoldWhile<B> where
F: FnMut(B, Self::Item) -> FoldWhile<B>,
[src]
F: FnMut(B, Self::Item) -> FoldWhile<B>,
fn sum1<S>(self) -> Option<S> where
S: Sum<Self::Item>,
[src]
S: Sum<Self::Item>,
fn product1<P>(self) -> Option<P> where
P: Product<Self::Item>,
[src]
P: Product<Self::Item>,
fn partition_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]
A: Default + Extend<L>,
B: Default + Extend<R>,
F: FnMut(Self::Item) -> Either<L, R>,
fn minmax(self) -> MinMaxResult<Self::Item> where
Self::Item: PartialOrd<Self::Item>,
[src]
Self::Item: PartialOrd<Self::Item>,
fn minmax_by_key<K, F>(self, key: F) -> MinMaxResult<Self::Item> where
F: FnMut(&Self::Item) -> K,
K: PartialOrd<K>,
[src]
F: FnMut(&Self::Item) -> K,
K: PartialOrd<K>,
fn minmax_by<F>(self, compare: F) -> MinMaxResult<Self::Item> where
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
[src]
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
fn exactly_one(self) -> Result<Self::Item, ExactlyOneError<Self>>
[src]
impl<D, A, I> MaybeProduct<D> for I where
A: Borrow<D>,
D: DimLike,
I: Iterator<Item = A>,
[src]
A: Borrow<D>,
D: DimLike,
I: Iterator<Item = A>,
fn maybe_product(self) -> Result<D, TractError>
[src]
impl<T> ToOwned for T where
T: Clone,
[src]
T: Clone,
type Owned = T
The resulting type after obtaining ownership.
fn to_owned(&self) -> T
[src]
fn clone_into(&self, target: &mut T)
[src]
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,