Struct malachite_nz::natural::conversion::to_limbs::LimbIterator
source · [−]pub struct LimbIterator<'a> { /* private fields */ }
Expand description
A double-ended iterator over the limbs of a Natural
.
The forward order is ascending (least-significant first). The iterator does not iterate over any implicit leading zero limbs.
This struct also supports retrieving limbs by index. This functionality is completely independent of the iterator’s state. Indexing the implicit leading zero limbs is allowed.
Trait Implementations
sourceimpl<'a> Clone for LimbIterator<'a>
impl<'a> Clone for LimbIterator<'a>
sourcefn clone(&self) -> LimbIterator<'a>ⓘNotable traits for LimbIterator<'a>impl<'a> Iterator for LimbIterator<'a> type Item = Limb;
fn clone(&self) -> LimbIterator<'a>ⓘNotable traits for LimbIterator<'a>impl<'a> Iterator for LimbIterator<'a> type Item = Limb;
1.0.0 · sourceconst fn clone_from(&mut self, source: &Self)
const fn clone_from(&mut self, source: &Self)
source
. Read moresourceimpl<'a> Debug for LimbIterator<'a>
impl<'a> Debug for LimbIterator<'a>
sourceimpl<'a> DoubleEndedIterator for LimbIterator<'a>
impl<'a> DoubleEndedIterator for LimbIterator<'a>
sourcefn next_back(&mut self) -> Option<Limb>
fn next_back(&mut self) -> Option<Limb>
A function to iterate through the limbs of a Natural
in descending order
(most-significant first).
Worst-case complexity
Constant time and additional memory.
Examples
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::basic::integers::PrimitiveInt;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::natural::Natural;
use malachite_nz::platform::Limb;
if Limb::WIDTH == u32::WIDTH {
assert_eq!(Natural::ZERO.limbs().next_back(), None);
// 10^12 = 232 * 2^32 + 3567587328
let trillion = Natural::from(10u32).pow(12);
let mut limbs = trillion.limbs();
assert_eq!(limbs.next_back(), Some(232));
assert_eq!(limbs.next_back(), Some(3567587328));
assert_eq!(limbs.next_back(), None);
}
sourcefn advance_back_by(&mut self, n: usize) -> Result<(), usize>
fn advance_back_by(&mut self, n: usize) -> Result<(), usize>
iter_advance_by
)n
elements. Read more1.37.0 · sourcefn nth_back(&mut self, n: usize) -> Option<Self::Item>
fn nth_back(&mut self, n: usize) -> Option<Self::Item>
n
th element from the end of the iterator. Read more1.27.0 · sourcefn try_rfold<B, F, R>(&mut self, init: B, f: F) -> Rwhere
F: FnMut(B, Self::Item) -> R,
R: Try<Output = B>,
fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> Rwhere
F: FnMut(B, Self::Item) -> R,
R: Try<Output = B>,
Iterator::try_fold()
: it takes
elements starting from the back of the iterator. Read moresourceimpl<'a> ExactSizeIterator for LimbIterator<'a>
impl<'a> ExactSizeIterator for LimbIterator<'a>
sourceimpl<'a> Hash for LimbIterator<'a>
impl<'a> Hash for LimbIterator<'a>
sourceimpl<'a> Index<usize> for LimbIterator<'a>
impl<'a> Index<usize> for LimbIterator<'a>
sourcefn index(&self, index: usize) -> &Limb
fn index(&self, index: usize) -> &Limb
A function to retrieve a Natural
’s limbs by index.
The index is the power of $2^W$ of which the limbs is a coefficient, where $W$ is the width of a limb. Indexing at or above the limb count returns zeros.
Worst-case complexity
Constant time and additional memory.
Examples
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::basic::integers::PrimitiveInt;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::natural::Natural;
use malachite_nz::platform::Limb;
if Limb::WIDTH == u32::WIDTH {
assert_eq!(Natural::ZERO.limbs()[0], 0);
// 10^12 = 232 * 2^32 + 3567587328
let trillion = Natural::from(10u32).pow(12);
let limbs = trillion.limbs();
assert_eq!(limbs[0], 3567587328);
assert_eq!(limbs[1], 232);
assert_eq!(limbs[2], 0);
assert_eq!(limbs[100], 0);
}
sourceimpl<'a> Iterator for LimbIterator<'a>
impl<'a> Iterator for LimbIterator<'a>
sourcefn next(&mut self) -> Option<Limb>
fn next(&mut self) -> Option<Limb>
A function to iterate through the limbs of a Natural
in ascending order
(least-significant first).
Worst-case complexity
Constant time and additional memory.
Examples
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::basic::integers::PrimitiveInt;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::natural::Natural;
use malachite_nz::platform::Limb;
if Limb::WIDTH == u32::WIDTH {
assert_eq!(Natural::ZERO.limbs().next(), None);
// 10^12 = 232 * 2^32 + 3567587328
let trillion = Natural::from(10u32).pow(12);
let mut limbs = trillion.limbs();
assert_eq!(limbs.next(), Some(3567587328));
assert_eq!(limbs.next(), Some(232));
assert_eq!(limbs.next(), None);
}
sourcefn size_hint(&self) -> (usize, Option<usize>)
fn size_hint(&self) -> (usize, Option<usize>)
sourcefn next_chunk<const N: usize>(
&mut self
) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
fn next_chunk<const N: usize>(
&mut self
) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
iter_next_chunk
)N
values. Read more1.0.0 · sourcefn count(self) -> usize
fn count(self) -> usize
1.0.0 · sourcefn last(self) -> Option<Self::Item>
fn last(self) -> Option<Self::Item>
sourcefn advance_by(&mut self, n: usize) -> Result<(), usize>
fn advance_by(&mut self, n: usize) -> Result<(), usize>
iter_advance_by
)n
elements. Read more1.0.0 · sourcefn 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 · sourcefn step_by(self, step: usize) -> StepBy<Self>
fn step_by(self, step: usize) -> StepBy<Self>
1.0.0 · sourcefn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>where
U: IntoIterator<Item = Self::Item>,
fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>where
U: IntoIterator<Item = Self::Item>,
1.0.0 · sourcefn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>where
U: IntoIterator,
fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>where
U: IntoIterator,
sourcefn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>where
G: FnMut() -> Self::Item,
fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>where
G: FnMut() -> Self::Item,
iter_intersperse
)separator
between adjacent items of the original iterator. Read more1.0.0 · sourcefn map<B, F>(self, f: F) -> Map<Self, F>where
F: FnMut(Self::Item) -> B,
fn map<B, F>(self, f: F) -> Map<Self, F>where
F: FnMut(Self::Item) -> B,
1.21.0 · sourcefn for_each<F>(self, f: F)where
F: FnMut(Self::Item),
fn for_each<F>(self, f: F)where
F: FnMut(Self::Item),
1.0.0 · sourcefn filter<P>(self, predicate: P) -> Filter<Self, P>where
P: FnMut(&Self::Item) -> bool,
fn filter<P>(self, predicate: P) -> Filter<Self, P>where
P: FnMut(&Self::Item) -> bool,
1.0.0 · sourcefn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>where
F: FnMut(Self::Item) -> Option<B>,
fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>where
F: FnMut(Self::Item) -> Option<B>,
1.0.0 · sourcefn enumerate(self) -> Enumerate<Self>
fn enumerate(self) -> Enumerate<Self>
1.0.0 · sourcefn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>where
P: FnMut(&Self::Item) -> bool,
fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>where
P: FnMut(&Self::Item) -> bool,
1.0.0 · sourcefn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>where
P: FnMut(&Self::Item) -> bool,
fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>where
P: FnMut(&Self::Item) -> bool,
1.57.0 · sourcefn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>where
P: FnMut(Self::Item) -> Option<B>,
fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>where
P: FnMut(Self::Item) -> Option<B>,
1.0.0 · sourcefn skip(self, n: usize) -> Skip<Self>
fn skip(self, n: usize) -> Skip<Self>
n
elements. Read more1.0.0 · sourcefn take(self, n: usize) -> Take<Self>
fn take(self, n: usize) -> Take<Self>
n
elements, or fewer
if the underlying iterator ends sooner. Read more1.0.0 · sourcefn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>where
F: FnMut(&mut St, Self::Item) -> Option<B>,
fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>where
F: FnMut(&mut St, Self::Item) -> Option<B>,
1.0.0 · sourcefn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>where
U: IntoIterator,
F: FnMut(Self::Item) -> U,
fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>where
U: IntoIterator,
F: FnMut(Self::Item) -> U,
1.0.0 · sourcefn inspect<F>(self, f: F) -> Inspect<Self, F>where
F: FnMut(&Self::Item),
fn inspect<F>(self, f: F) -> Inspect<Self, F>where
F: FnMut(&Self::Item),
1.0.0 · sourcefn by_ref(&mut self) -> &mut Self
fn by_ref(&mut self) -> &mut Self
1.0.0 · sourcefn collect<B>(self) -> Bwhere
B: FromIterator<Self::Item>,
fn collect<B>(self) -> Bwhere
B: FromIterator<Self::Item>,
sourcefn collect_into<E>(self, collection: &mut E) -> &mut Ewhere
E: Extend<Self::Item>,
fn collect_into<E>(self, collection: &mut E) -> &mut Ewhere
E: Extend<Self::Item>,
iter_collect_into
)1.0.0 · sourcefn partition<B, F>(self, f: F) -> (B, B)where
B: Default + Extend<Self::Item>,
F: FnMut(&Self::Item) -> bool,
fn partition<B, F>(self, f: F) -> (B, B)where
B: Default + Extend<Self::Item>,
F: FnMut(&Self::Item) -> bool,
sourcefn partition_in_place<'a, T, P>(self, predicate: P) -> usizewhere
T: 'a,
Self: DoubleEndedIterator<Item = &'a mut T>,
P: FnMut(&T) -> bool,
fn partition_in_place<'a, T, P>(self, predicate: P) -> usizewhere
T: 'a,
Self: DoubleEndedIterator<Item = &'a mut T>,
P: FnMut(&T) -> bool,
iter_partition_in_place
)true
precede all those that return false
.
Returns the number of true
elements found. Read moresourcefn is_partitioned<P>(self, predicate: P) -> boolwhere
P: FnMut(Self::Item) -> bool,
fn is_partitioned<P>(self, predicate: P) -> boolwhere
P: FnMut(Self::Item) -> bool,
iter_is_partitioned
)true
precede all those that return false
. Read more1.27.0 · sourcefn try_fold<B, F, R>(&mut self, init: B, f: F) -> Rwhere
F: FnMut(B, Self::Item) -> R,
R: Try<Output = B>,
fn try_fold<B, F, R>(&mut self, init: B, f: F) -> Rwhere
F: FnMut(B, Self::Item) -> R,
R: Try<Output = B>,
1.27.0 · sourcefn try_for_each<F, R>(&mut self, f: F) -> Rwhere
F: FnMut(Self::Item) -> R,
R: Try<Output = ()>,
fn try_for_each<F, R>(&mut self, f: F) -> Rwhere
F: FnMut(Self::Item) -> R,
R: Try<Output = ()>,
1.0.0 · sourcefn fold<B, F>(self, init: B, f: F) -> Bwhere
F: FnMut(B, Self::Item) -> B,
fn fold<B, F>(self, init: B, f: F) -> Bwhere
F: FnMut(B, Self::Item) -> B,
1.51.0 · sourcefn reduce<F>(self, f: F) -> Option<Self::Item>where
F: FnMut(Self::Item, Self::Item) -> Self::Item,
fn reduce<F>(self, f: F) -> Option<Self::Item>where
F: FnMut(Self::Item, Self::Item) -> Self::Item,
sourcefn try_reduce<F, R>(
&mut self,
f: F
) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryTypewhere
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
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 · sourcefn all<F>(&mut self, f: F) -> boolwhere
F: FnMut(Self::Item) -> bool,
fn all<F>(&mut self, f: F) -> boolwhere
F: FnMut(Self::Item) -> bool,
1.0.0 · sourcefn any<F>(&mut self, f: F) -> boolwhere
F: FnMut(Self::Item) -> bool,
fn any<F>(&mut self, f: F) -> boolwhere
F: FnMut(Self::Item) -> bool,
1.0.0 · sourcefn find<P>(&mut self, predicate: P) -> Option<Self::Item>where
P: FnMut(&Self::Item) -> bool,
fn find<P>(&mut self, predicate: P) -> Option<Self::Item>where
P: FnMut(&Self::Item) -> bool,
1.30.0 · sourcefn find_map<B, F>(&mut self, f: F) -> Option<B>where
F: FnMut(Self::Item) -> Option<B>,
fn find_map<B, F>(&mut self, f: F) -> Option<B>where
F: FnMut(Self::Item) -> Option<B>,
sourcefn try_find<F, R>(
&mut self,
f: F
) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryTypewhere
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
F: FnMut(&Self::Item) -> R,
R: Try<Output = bool>,
<R as Try>::Residual: Residual<Option<Self::Item>>,
try_find
)1.0.0 · sourcefn position<P>(&mut self, predicate: P) -> Option<usize>where
P: FnMut(Self::Item) -> bool,
fn position<P>(&mut self, predicate: P) -> Option<usize>where
P: FnMut(Self::Item) -> bool,
1.0.0 · sourcefn rposition<P>(&mut self, predicate: P) -> Option<usize>where
P: FnMut(Self::Item) -> bool,
Self: ExactSizeIterator + DoubleEndedIterator,
fn rposition<P>(&mut self, predicate: P) -> Option<usize>where
P: FnMut(Self::Item) -> bool,
Self: ExactSizeIterator + DoubleEndedIterator,
1.6.0 · sourcefn max_by_key<B, F>(self, f: F) -> Option<Self::Item>where
B: Ord,
F: FnMut(&Self::Item) -> B,
fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>where
B: Ord,
F: FnMut(&Self::Item) -> B,
1.15.0 · sourcefn max_by<F>(self, compare: F) -> Option<Self::Item>where
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
fn max_by<F>(self, compare: F) -> Option<Self::Item>where
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
1.6.0 · sourcefn min_by_key<B, F>(self, f: F) -> Option<Self::Item>where
B: Ord,
F: FnMut(&Self::Item) -> B,
fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>where
B: Ord,
F: FnMut(&Self::Item) -> B,
1.15.0 · sourcefn min_by<F>(self, compare: F) -> Option<Self::Item>where
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
fn min_by<F>(self, compare: F) -> Option<Self::Item>where
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
1.0.0 · sourcefn rev(self) -> Rev<Self>where
Self: DoubleEndedIterator,
fn rev(self) -> Rev<Self>where
Self: DoubleEndedIterator,
1.0.0 · sourcefn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)where
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
Self: Iterator<Item = (A, B)>,
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)where
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
Self: Iterator<Item = (A, B)>,
1.36.0 · sourcefn copied<'a, T>(self) -> Copied<Self>where
T: 'a + Copy,
Self: Iterator<Item = &'a T>,
fn copied<'a, T>(self) -> Copied<Self>where
T: 'a + Copy,
Self: Iterator<Item = &'a T>,
1.0.0 · sourcefn cloned<'a, T>(self) -> Cloned<Self>where
T: 'a + Clone,
Self: Iterator<Item = &'a T>,
fn cloned<'a, T>(self) -> Cloned<Self>where
T: 'a + Clone,
Self: Iterator<Item = &'a T>,
1.0.0 · sourcefn cycle(self) -> Cycle<Self>where
Self: Clone,
fn cycle(self) -> Cycle<Self>where
Self: Clone,
sourcefn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
iter_array_chunks
)N
elements of the iterator at a time. Read more1.11.0 · sourcefn sum<S>(self) -> Swhere
S: Sum<Self::Item>,
fn sum<S>(self) -> Swhere
S: Sum<Self::Item>,
1.11.0 · sourcefn product<P>(self) -> Pwhere
P: Product<Self::Item>,
fn product<P>(self) -> Pwhere
P: Product<Self::Item>,
sourcefn cmp_by<I, F>(self, other: I, cmp: F) -> Orderingwhere
I: IntoIterator,
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
fn cmp_by<I, F>(self, other: I, cmp: F) -> Orderingwhere
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 · sourcefn partial_cmp<I>(self, other: I) -> Option<Ordering>where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
fn partial_cmp<I>(self, other: I) -> Option<Ordering>where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
sourcefn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>where
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
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 · sourcefn eq<I>(self, other: I) -> boolwhere
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>,
fn eq<I>(self, other: I) -> boolwhere
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>,
sourcefn eq_by<I, F>(self, other: I, eq: F) -> boolwhere
I: IntoIterator,
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
fn eq_by<I, F>(self, other: I, eq: F) -> boolwhere
I: IntoIterator,
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
iter_order_by
)1.5.0 · sourcefn ne<I>(self, other: I) -> boolwhere
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>,
fn ne<I>(self, other: I) -> boolwhere
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>,
1.5.0 · sourcefn lt<I>(self, other: I) -> boolwhere
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
fn lt<I>(self, other: I) -> boolwhere
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
Iterator
are lexicographically
less than those of another. Read more1.5.0 · sourcefn le<I>(self, other: I) -> boolwhere
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
fn le<I>(self, other: I) -> boolwhere
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
Iterator
are lexicographically
less or equal to those of another. Read more1.5.0 · sourcefn gt<I>(self, other: I) -> boolwhere
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
fn gt<I>(self, other: I) -> boolwhere
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
Iterator
are lexicographically
greater than those of another. Read more1.5.0 · sourcefn ge<I>(self, other: I) -> boolwhere
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
fn ge<I>(self, other: I) -> boolwhere
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
Iterator
are lexicographically
greater than or equal to those of another. Read moresourcefn is_sorted_by<F>(self, compare: F) -> boolwhere
F: FnMut(&Self::Item, &Self::Item) -> Option<Ordering>,
fn is_sorted_by<F>(self, compare: F) -> boolwhere
F: FnMut(&Self::Item, &Self::Item) -> Option<Ordering>,
is_sorted
)sourcefn is_sorted_by_key<F, K>(self, f: F) -> boolwhere
F: FnMut(Self::Item) -> K,
K: PartialOrd<K>,
fn is_sorted_by_key<F, K>(self, f: F) -> boolwhere
F: FnMut(Self::Item) -> K,
K: PartialOrd<K>,
is_sorted
)sourceimpl<'a> PartialEq<LimbIterator<'a>> for LimbIterator<'a>
impl<'a> PartialEq<LimbIterator<'a>> for LimbIterator<'a>
sourcefn eq(&self, other: &LimbIterator<'a>) -> bool
fn eq(&self, other: &LimbIterator<'a>) -> bool
impl<'a> Copy for LimbIterator<'a>
impl<'a> Eq for LimbIterator<'a>
impl<'a> StructuralEq for LimbIterator<'a>
impl<'a> StructuralPartialEq for LimbIterator<'a>
Auto Trait Implementations
impl<'a> RefUnwindSafe for LimbIterator<'a>
impl<'a> Send for LimbIterator<'a>
impl<'a> Sync for LimbIterator<'a>
impl<'a> Unpin for LimbIterator<'a>
impl<'a> UnwindSafe for LimbIterator<'a>
Blanket Implementations
sourceimpl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
const: unstable · sourcefn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
sourceimpl<T, U> ExactFrom<T> for Uwhere
U: TryFrom<T>,
impl<T, U> ExactFrom<T> for Uwhere
U: TryFrom<T>,
fn exact_from(value: T) -> U
sourceimpl<T, U> ExactInto<U> for Twhere
U: ExactFrom<T>,
impl<T, U> ExactInto<U> for Twhere
U: ExactFrom<T>,
fn exact_into(self) -> U
sourceimpl<I> IntoIterator for Iwhere
I: Iterator,
impl<I> IntoIterator for Iwhere
I: Iterator,
sourceimpl<I> IteratorRandom for Iwhere
I: Iterator,
impl<I> IteratorRandom for Iwhere
I: Iterator,
sourcefn choose<R>(self, rng: &mut R) -> Option<Self::Item>where
R: Rng + ?Sized,
fn choose<R>(self, rng: &mut R) -> Option<Self::Item>where
R: Rng + ?Sized,
sourceimpl<T> Itertools for Twhere
T: Iterator + ?Sized,
impl<T> Itertools for Twhere
T: Iterator + ?Sized,
sourcefn interleave<J>(
self,
other: J
) -> Interleave<Self, <J as IntoIterator>::IntoIter>where
J: IntoIterator<Item = Self::Item>,
fn interleave<J>(
self,
other: J
) -> Interleave<Self, <J as IntoIterator>::IntoIter>where
J: IntoIterator<Item = Self::Item>,
sourcefn interleave_shortest<J>(
self,
other: J
) -> InterleaveShortest<Self, <J as IntoIterator>::IntoIter>where
J: IntoIterator<Item = Self::Item>,
fn interleave_shortest<J>(
self,
other: J
) -> InterleaveShortest<Self, <J as IntoIterator>::IntoIter>where
J: IntoIterator<Item = Self::Item>,
sourcefn intersperse(self, element: Self::Item) -> Intersperse<Self>where
Self::Item: Clone,
fn intersperse(self, element: Self::Item) -> Intersperse<Self>where
Self::Item: Clone,
sourcefn zip_longest<J>(
self,
other: J
) -> ZipLongest<Self, <J as IntoIterator>::IntoIter>where
J: IntoIterator,
fn zip_longest<J>(
self,
other: J
) -> ZipLongest<Self, <J as IntoIterator>::IntoIter>where
J: IntoIterator,
sourcefn zip_eq<J>(self, other: J) -> ZipEq<Self, <J as IntoIterator>::IntoIter>where
J: IntoIterator,
fn zip_eq<J>(self, other: J) -> ZipEq<Self, <J as IntoIterator>::IntoIter>where
J: IntoIterator,
sourcefn batching<B, F>(self, f: F) -> Batching<Self, F>where
F: FnMut(&mut Self) -> Option<B>,
fn batching<B, F>(self, f: F) -> Batching<Self, F>where
F: FnMut(&mut Self) -> Option<B>,
sourcefn group_by<K, F>(self, key: F) -> GroupBy<K, Self, F>where
F: FnMut(&Self::Item) -> K,
K: PartialEq<K>,
fn group_by<K, F>(self, key: F) -> GroupBy<K, Self, F>where
F: FnMut(&Self::Item) -> K,
K: PartialEq<K>,
sourcefn chunks(self, size: usize) -> IntoChunks<Self>
fn chunks(self, size: usize) -> IntoChunks<Self>
sourcefn tuple_windows<T>(self) -> TupleWindows<Self, T>where
Self: Iterator<Item = <T as TupleCollect>::Item>,
T: HomogeneousTuple,
<T as TupleCollect>::Item: Clone,
fn tuple_windows<T>(self) -> TupleWindows<Self, T>where
Self: Iterator<Item = <T as TupleCollect>::Item>,
T: HomogeneousTuple,
<T as TupleCollect>::Item: Clone,
sourcefn tuples<T>(self) -> Tuples<Self, T>where
Self: Iterator<Item = <T as TupleCollect>::Item>,
T: HomogeneousTuple,
fn tuples<T>(self) -> Tuples<Self, T>where
Self: Iterator<Item = <T as TupleCollect>::Item>,
T: HomogeneousTuple,
sourcefn tee(self) -> (Tee<Self>, Tee<Self>)where
Self::Item: Clone,
fn tee(self) -> (Tee<Self>, Tee<Self>)where
Self::Item: Clone,
sourcefn step(self, n: usize) -> Step<Self>
fn step(self, n: usize) -> Step<Self>
n
elements in the base iterator
for each iteration. Read moresourcefn map_into<R>(self) -> MapInto<Self, R>where
Self::Item: Into<R>,
fn map_into<R>(self) -> MapInto<Self, R>where
Self::Item: Into<R>,
Into
trait. Read moresourcefn map_results<F, T, U, E>(self, f: F) -> MapResults<Self, F>where
Self: Iterator<Item = Result<T, E>>,
F: FnMut(T) -> U,
fn map_results<F, T, U, E>(self, f: F) -> MapResults<Self, F>where
Self: Iterator<Item = Result<T, E>>,
F: FnMut(T) -> U,
Result::Ok
value. Result::Err
values are
unchanged. Read moresourcefn merge<J>(
self,
other: J
) -> MergeBy<Self, <J as IntoIterator>::IntoIter, MergeLte>where
Self::Item: PartialOrd<Self::Item>,
J: IntoIterator<Item = Self::Item>,
fn merge<J>(
self,
other: J
) -> MergeBy<Self, <J as IntoIterator>::IntoIter, MergeLte>where
Self::Item: PartialOrd<Self::Item>,
J: IntoIterator<Item = Self::Item>,
sourcefn merge_by<J, F>(
self,
other: J,
is_first: F
) -> MergeBy<Self, <J as IntoIterator>::IntoIter, F>where
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
J: IntoIterator<Item = Self::Item>,
F: FnMut(&Self::Item, &Self::Item) -> bool,
.merge()
but allows for a custom ordering. Read moresourcefn merge_join_by<J, F>(
self,
other: J,
cmp_fn: F
) -> MergeJoinBy<Self, <J as IntoIterator>::IntoIter, F>where
J: IntoIterator,
F: FnMut(&Self::Item, &<J as IntoIterator>::Item) -> Ordering,
fn merge_join_by<J, F>(
self,
other: J,
cmp_fn: F
) -> MergeJoinBy<Self, <J as IntoIterator>::IntoIter, F>where
J: IntoIterator,
F: FnMut(&Self::Item, &<J as IntoIterator>::Item) -> Ordering,
sourcefn kmerge(self) -> KMergeBy<<Self::Item as IntoIterator>::IntoIter, KMergeByLt>where
Self::Item: IntoIterator,
<Self::Item as IntoIterator>::Item: PartialOrd<<Self::Item as IntoIterator>::Item>,
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>,
sourcefn kmerge_by<F>(
self,
first: F
) -> KMergeBy<<Self::Item as IntoIterator>::IntoIter, F>where
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::Item: IntoIterator,
F: FnMut(&<Self::Item as IntoIterator>::Item, &<Self::Item as IntoIterator>::Item) -> bool,
sourcefn cartesian_product<J>(
self,
other: J
) -> Product<Self, <J as IntoIterator>::IntoIter>where
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::Item: Clone,
J: IntoIterator,
<J as IntoIterator>::IntoIter: Clone,
self
and J
. Read moresourcefn 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,
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,
self
. Read moresourcefn coalesce<F>(self, f: F) -> Coalesce<Self, F>where
F: FnMut(Self::Item, Self::Item) -> Result<Self::Item, (Self::Item, Self::Item)>,
fn coalesce<F>(self, f: F) -> Coalesce<Self, F>where
F: FnMut(Self::Item, Self::Item) -> Result<Self::Item, (Self::Item, Self::Item)>,
sourcefn dedup(self) -> DedupBy<Self, DedupEq>where
Self::Item: PartialEq<Self::Item>,
fn dedup(self) -> DedupBy<Self, DedupEq>where
Self::Item: PartialEq<Self::Item>,
sourcefn dedup_by<Cmp>(self, cmp: Cmp) -> DedupBy<Self, Cmp>where
Cmp: FnMut(&Self::Item, &Self::Item) -> bool,
fn dedup_by<Cmp>(self, cmp: Cmp) -> DedupBy<Self, Cmp>where
Cmp: FnMut(&Self::Item, &Self::Item) -> bool,
sourcefn unique(self) -> Unique<Self>where
Self::Item: Clone + Eq + Hash,
fn unique(self) -> Unique<Self>where
Self::Item: Clone + Eq + Hash,
sourcefn unique_by<V, F>(self, f: F) -> UniqueBy<Self, V, F>where
V: Eq + Hash,
F: FnMut(&Self::Item) -> V,
fn unique_by<V, F>(self, f: F) -> UniqueBy<Self, V, F>where
V: Eq + Hash,
F: FnMut(&Self::Item) -> V,
sourcefn peeking_take_while<F>(&mut self, accept: F) -> PeekingTakeWhile<'_, Self, F>where
Self: PeekingNext,
F: FnMut(&Self::Item) -> bool,
fn peeking_take_while<F>(&mut self, accept: F) -> PeekingTakeWhile<'_, Self, F>where
Self: PeekingNext,
F: FnMut(&Self::Item) -> bool,
accept
returns true
. Read moresourcefn 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 moresourcefn while_some<A>(self) -> WhileSome<Self>where
Self: Iterator<Item = Option<A>>,
fn while_some<A>(self) -> WhileSome<Self>where
Self: Iterator<Item = Option<A>>,
Option<A>
iterator elements
and produces A
. Stops on the first None
encountered. Read moresourcefn tuple_combinations<T>(self) -> TupleCombinations<Self, T>where
Self: Clone,
Self::Item: Clone,
T: HasCombination<Self>,
fn tuple_combinations<T>(self) -> TupleCombinations<Self, T>where
Self: Clone,
Self::Item: Clone,
T: HasCombination<Self>,
sourcefn combinations(self, k: usize) -> Combinations<Self>where
Self::Item: Clone,
fn combinations(self, k: usize) -> Combinations<Self>where
Self::Item: Clone,
k
-length combinations of
the elements from an iterator. Read moresourcefn combinations_with_replacement(
self,
k: usize
) -> CombinationsWithReplacement<Self>where
Self::Item: Clone,
fn combinations_with_replacement(
self,
k: usize
) -> CombinationsWithReplacement<Self>where
Self::Item: Clone,
k
-length combinations of
the elements from an iterator, with replacement. Read moresourcefn permutations(self, k: usize) -> Permutations<Self>where
Self::Item: Clone,
fn permutations(self, k: usize) -> Permutations<Self>where
Self::Item: Clone,
sourcefn pad_using<F>(self, min: usize, f: F) -> PadUsing<Self, F>where
F: FnMut(usize) -> Self::Item,
fn pad_using<F>(self, min: usize, f: F) -> PadUsing<Self, F>where
F: FnMut(usize) -> Self::Item,
min
by filling missing elements using a closure f
. Read moresourcefn with_position(self) -> WithPosition<Self>
fn with_position(self) -> WithPosition<Self>
Position
to
ease special-case handling of the first or last elements. Read moresourcefn positions<P>(self, predicate: P) -> Positions<Self, P>where
P: FnMut(Self::Item) -> bool,
fn positions<P>(self, predicate: P) -> Positions<Self, P>where
P: FnMut(Self::Item) -> bool,
sourcefn update<F>(self, updater: F) -> Update<Self, F>where
F: FnMut(&mut Self::Item),
fn update<F>(self, updater: F) -> Update<Self, F>where
F: FnMut(&mut Self::Item),
sourcefn next_tuple<T>(&mut self) -> Option<T>where
Self: Iterator<Item = <T as TupleCollect>::Item>,
T: HomogeneousTuple,
fn next_tuple<T>(&mut self) -> Option<T>where
Self: Iterator<Item = <T as TupleCollect>::Item>,
T: HomogeneousTuple,
sourcefn collect_tuple<T>(self) -> Option<T>where
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,
sourcefn 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,
sourcefn all_equal(&mut self) -> boolwhere
Self::Item: PartialEq<Self::Item>,
fn all_equal(&mut self) -> boolwhere
Self::Item: PartialEq<Self::Item>,
sourcefn dropping(self, n: usize) -> Self
fn dropping(self, n: usize) -> Self
n
elements from the iterator eagerly,
and return the same iterator again. Read moresourcefn dropping_back(self, n: usize) -> Selfwhere
Self: DoubleEndedIterator,
fn dropping_back(self, n: usize) -> Selfwhere
Self: DoubleEndedIterator,
n
elements from the iterator eagerly,
and return the same iterator again. Read moresourcefn foreach<F>(self, f: F)where
F: FnMut(Self::Item),
fn foreach<F>(self, f: F)where
F: FnMut(Self::Item),
f
eagerly on each element of the iterator. Read moresourcefn concat(self) -> Self::Itemwhere
Self::Item: Extend<<Self::Item as IntoIterator>::Item> + IntoIterator + Default,
fn concat(self) -> Self::Itemwhere
Self::Item: Extend<<Self::Item as IntoIterator>::Item> + IntoIterator + Default,
Extend
. Read moresourcefn collect_vec(self) -> Vec<Self::Item, Global>
fn collect_vec(self) -> Vec<Self::Item, Global>
sourcefn try_collect<T, U, E>(self) -> Result<U, E>where
Self: Iterator<Item = Result<T, E>>,
Result<U, E>: FromIterator<Result<T, E>>,
fn try_collect<T, U, E>(self) -> Result<U, E>where
Self: Iterator<Item = Result<T, E>>,
Result<U, E>: FromIterator<Result<T, E>>,
sourcefn 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 moresourcefn join(&mut self, sep: &str) -> Stringwhere
Self::Item: Display,
fn join(&mut self, sep: &str) -> Stringwhere
Self::Item: Display,
sep
. Read moresourcefn format(self, sep: &str) -> Format<'_, Self>
fn format(self, sep: &str) -> Format<'_, Self>
sep
. Read moresourcefn format_with<F>(self, sep: &str, format: F) -> FormatWith<'_, Self, F>where
F: FnMut(Self::Item, &mut dyn FnMut(&dyn Display)) -> Result<(), Error>,
fn format_with<F>(self, sep: &str, format: F) -> FormatWith<'_, Self, F>where
F: FnMut(Self::Item, &mut dyn FnMut(&dyn Display)) -> Result<(), Error>,
sep
. Read moresourcefn 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,
Result
values from an iterator. Read moresourcefn 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 moresourcefn fold1<F>(self, f: F) -> Option<Self::Item>where
F: FnMut(Self::Item, Self::Item) -> Self::Item,
fn fold1<F>(self, f: F) -> Option<Self::Item>where
F: FnMut(Self::Item, Self::Item) -> Self::Item,
sourcefn tree_fold1<F>(self, f: F) -> Option<Self::Item>where
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,
sourcefn fold_while<B, F>(&mut self, init: B, f: F) -> FoldWhile<B>where
F: FnMut(B, Self::Item) -> FoldWhile<B>,
fn fold_while<B, F>(&mut self, init: B, f: F) -> FoldWhile<B>where
F: FnMut(B, Self::Item) -> FoldWhile<B>,
sourcefn sum1<S>(self) -> Option<S>where
S: Sum<Self::Item>,
fn sum1<S>(self) -> Option<S>where
S: Sum<Self::Item>,
sourcefn product1<P>(self) -> Option<P>where
P: Product<Self::Item>,
fn product1<P>(self) -> Option<P>where
P: Product<Self::Item>,
sourcefn sorted(self) -> IntoIter<Self::Item, Global>where
Self::Item: Ord,
fn sorted(self) -> IntoIter<Self::Item, Global>where
Self::Item: Ord,
sourcefn sorted_by<F>(self, cmp: F) -> IntoIter<Self::Item, Global>where
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
fn sorted_by<F>(self, cmp: F) -> IntoIter<Self::Item, Global>where
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
sourcefn sorted_by_key<K, F>(self, f: F) -> IntoIter<Self::Item, Global>where
K: Ord,
F: FnMut(&Self::Item) -> K,
fn sorted_by_key<K, F>(self, f: F) -> IntoIter<Self::Item, Global>where
K: Ord,
F: FnMut(&Self::Item) -> K,
sourcefn partition_map<A, B, F, L, R>(self, predicate: F) -> (A, B)where
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
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 moresourcefn into_group_map<K, V>(self) -> HashMap<K, Vec<V, Global>, RandomState>where
Self: Iterator<Item = (K, V)>,
K: Hash + Eq,
fn into_group_map<K, V>(self) -> HashMap<K, Vec<V, Global>, RandomState>where
Self: Iterator<Item = (K, V)>,
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 more