Struct malachite_base::num::random::striped::StripedBitSource
source · pub struct StripedBitSource { /* private fields */ }Expand description
Generates bits from a striped random sequence.
See here for more information.
Implementations§
source§impl StripedBitSource
impl StripedBitSource
sourcepub fn new(seed: Seed, m_numerator: u64, m_denominator: u64) -> StripedBitSource ⓘ
pub fn new(seed: Seed, m_numerator: u64, m_denominator: u64) -> StripedBitSource ⓘ
Creates a new StripedBitSource.
The mean run length is $m$, where $m$ is m_numerator / m_denominator.
Expected complexity
Constant time and additional memory.
Panics
Panics if m_denominator is zero or if m_numerator <= m_denominator.
Examples
use malachite_base::num::random::striped::StripedBitSource;
use malachite_base::random::EXAMPLE_SEED;
let mut bit_source = StripedBitSource::new(EXAMPLE_SEED, 4, 1);
let mut string = String::with_capacity(40);
for bit in bit_source.take(40) {
if bit {
string.push('1');
} else {
string.push('0');
}
}
assert_eq!(string, "0000000101100110000000011110000000001111");sourcepub fn end_block(&mut self)
pub fn end_block(&mut self)
Resets this StripedBitSource, so that the next time next is called, the
probabilities of true or false will be equal.
Expected complexity
Constant time and additional memory.
Examples
use malachite_base::num::random::striped::StripedBitSource;
use malachite_base::random::EXAMPLE_SEED;
fn generate_string(bit_source: &mut StripedBitSource) -> String {
let mut string = String::with_capacity(40);
for bit in bit_source.take(40) {
if bit {
string.push('1');
} else {
string.push('0');
}
}
string
}
let mut bit_source = StripedBitSource::new(EXAMPLE_SEED, 1000000, 1);
let mut strings = Vec::with_capacity(5);
for _ in 0..5 {
strings.push(generate_string(&mut bit_source));
bit_source.end_block();
}
assert_eq!(
strings,
&[
"0000000000000000000000000000000000000000",
"0000000000000000000000000000000000000000",
"0000000000000000000000000000000000000000",
"1111111111111111111111111111111111111111",
"0000000000000000000000000000000000000000"
]
);sourcepub fn set_previous_bit(&mut self, bit: bool)
pub fn set_previous_bit(&mut self, bit: bool)
Sets the previous bit of a StripedBitSource. This will affect the probability of the next
bit.
Expected complexity
Constant time and additional memory.
Examples
use malachite_base::num::random::striped::StripedBitSource;
use malachite_base::random::EXAMPLE_SEED;
fn generate_string(bit_source: &mut StripedBitSource) -> String {
let mut string = String::with_capacity(40);
for bit in bit_source.take(40) {
if bit {
string.push('1');
} else {
string.push('0');
}
}
string
}
let mut bit_source = StripedBitSource::new(EXAMPLE_SEED, 1000000, 1);
bit_source.next();
let mut strings = Vec::with_capacity(3);
bit_source.set_previous_bit(true);
strings.push(generate_string(&mut bit_source));
bit_source.set_previous_bit(false);
strings.push(generate_string(&mut bit_source));
bit_source.set_previous_bit(true);
strings.push(generate_string(&mut bit_source));
assert_eq!(
strings,
&[
"1111111111111111111111111111111111111111",
"0000000000000000000000000000000000000000",
"1111111111111111111111111111111111111111",
]
);Trait Implementations§
source§impl Clone for StripedBitSource
impl Clone for StripedBitSource
source§impl Debug for StripedBitSource
impl Debug for StripedBitSource
source§impl Iterator for StripedBitSource
impl Iterator for StripedBitSource
source§fn next(&mut self) -> Option<bool>
fn next(&mut self) -> Option<bool>
Gets a bit from this StripedBitSource. If this function is being called for the first
time, the probabilities of a true or a false are equal. On subsequent calls, the
probability of getting a bit different from the previous one is $1 / m$.
To reset the bit source, so that the next call to next has equal probabilities of true
or false, call end_block.
Expected complexity
Constant time and additional memory.
source§fn next_chunk<const N: usize>(
&mut self
) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>where
Self: Sized,
fn next_chunk<const N: usize>(
&mut self
) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>where
Self: Sized,
iter_next_chunk)N values. Read more1.0.0 · source§fn size_hint(&self) -> (usize, Option<usize>)
fn size_hint(&self) -> (usize, Option<usize>)
1.0.0 · source§fn count(self) -> usizewhere
Self: Sized,
fn count(self) -> usizewhere
Self: Sized,
1.0.0 · source§fn last(self) -> Option<Self::Item>where
Self: Sized,
fn last(self) -> Option<Self::Item>where
Self: Sized,
source§fn advance_by(&mut self, n: usize) -> Result<(), usize>
fn advance_by(&mut self, n: usize) -> Result<(), usize>
iter_advance_by)n elements. Read more1.0.0 · source§fn nth(&mut self, n: usize) -> Option<Self::Item>
fn nth(&mut self, n: usize) -> Option<Self::Item>
nth element of the iterator. Read more1.28.0 · source§fn step_by(self, step: usize) -> StepBy<Self>where
Self: Sized,
fn step_by(self, step: usize) -> StepBy<Self>where
Self: Sized,
1.0.0 · source§fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>where
Self: Sized,
U: IntoIterator<Item = Self::Item>,
fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>where
Self: Sized,
U: IntoIterator<Item = Self::Item>,
1.0.0 · source§fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>where
Self: Sized,
U: IntoIterator,
fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>where
Self: Sized,
U: IntoIterator,
source§fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>where
Self: Sized,
G: FnMut() -> Self::Item,
fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>where
Self: Sized,
G: FnMut() -> Self::Item,
iter_intersperse)separator
between adjacent items of the original iterator. Read more1.0.0 · source§fn map<B, F>(self, f: F) -> Map<Self, F>where
Self: Sized,
F: FnMut(Self::Item) -> B,
fn map<B, F>(self, f: F) -> Map<Self, F>where
Self: Sized,
F: FnMut(Self::Item) -> B,
1.21.0 · source§fn for_each<F>(self, f: F)where
Self: Sized,
F: FnMut(Self::Item),
fn for_each<F>(self, f: F)where
Self: Sized,
F: FnMut(Self::Item),
1.0.0 · source§fn filter<P>(self, predicate: P) -> Filter<Self, P>where
Self: Sized,
P: FnMut(&Self::Item) -> bool,
fn filter<P>(self, predicate: P) -> Filter<Self, P>where
Self: Sized,
P: FnMut(&Self::Item) -> bool,
1.0.0 · source§fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>where
Self: Sized,
F: FnMut(Self::Item) -> Option<B>,
fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>where
Self: Sized,
F: FnMut(Self::Item) -> Option<B>,
1.0.0 · source§fn enumerate(self) -> Enumerate<Self>where
Self: Sized,
fn enumerate(self) -> Enumerate<Self>where
Self: Sized,
1.0.0 · source§fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>where
Self: Sized,
P: FnMut(&Self::Item) -> bool,
fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>where
Self: Sized,
P: FnMut(&Self::Item) -> bool,
1.0.0 · source§fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>where
Self: Sized,
P: FnMut(&Self::Item) -> bool,
fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>where
Self: Sized,
P: FnMut(&Self::Item) -> bool,
1.57.0 · source§fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>where
Self: Sized,
P: FnMut(Self::Item) -> Option<B>,
fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>where
Self: Sized,
P: FnMut(Self::Item) -> Option<B>,
1.0.0 · source§fn skip(self, n: usize) -> Skip<Self>where
Self: Sized,
fn skip(self, n: usize) -> Skip<Self>where
Self: Sized,
n elements. Read more1.0.0 · source§fn take(self, n: usize) -> Take<Self>where
Self: Sized,
fn take(self, n: usize) -> Take<Self>where
Self: Sized,
n elements, or fewer
if the underlying iterator ends sooner. Read more1.0.0 · source§fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>where
Self: Sized,
F: FnMut(&mut St, Self::Item) -> Option<B>,
fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>where
Self: Sized,
F: FnMut(&mut St, Self::Item) -> Option<B>,
1.0.0 · source§fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>where
Self: Sized,
U: IntoIterator,
F: FnMut(Self::Item) -> U,
fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>where
Self: Sized,
U: IntoIterator,
F: FnMut(Self::Item) -> U,
1.0.0 · source§fn inspect<F>(self, f: F) -> Inspect<Self, F>where
Self: Sized,
F: FnMut(&Self::Item),
fn inspect<F>(self, f: F) -> Inspect<Self, F>where
Self: Sized,
F: FnMut(&Self::Item),
1.0.0 · source§fn by_ref(&mut self) -> &mut Selfwhere
Self: Sized,
fn by_ref(&mut self) -> &mut Selfwhere
Self: Sized,
1.0.0 · source§fn collect<B>(self) -> Bwhere
B: FromIterator<Self::Item>,
Self: Sized,
fn collect<B>(self) -> Bwhere
B: FromIterator<Self::Item>,
Self: Sized,
source§fn collect_into<E>(self, collection: &mut E) -> &mut Ewhere
E: Extend<Self::Item>,
Self: Sized,
fn collect_into<E>(self, collection: &mut E) -> &mut Ewhere
E: Extend<Self::Item>,
Self: Sized,
iter_collect_into)1.0.0 · source§fn partition<B, F>(self, f: F) -> (B, B)where
Self: Sized,
B: Default + Extend<Self::Item>,
F: FnMut(&Self::Item) -> bool,
fn partition<B, F>(self, f: F) -> (B, B)where
Self: Sized,
B: Default + Extend<Self::Item>,
F: FnMut(&Self::Item) -> bool,
source§fn is_partitioned<P>(self, predicate: P) -> boolwhere
Self: Sized,
P: FnMut(Self::Item) -> bool,
fn is_partitioned<P>(self, predicate: P) -> boolwhere
Self: Sized,
P: FnMut(Self::Item) -> bool,
iter_is_partitioned)true precede all those that return false. Read more1.27.0 · source§fn try_fold<B, F, R>(&mut self, init: B, f: F) -> Rwhere
Self: Sized,
F: FnMut(B, Self::Item) -> R,
R: Try<Output = B>,
fn try_fold<B, F, R>(&mut self, init: B, f: F) -> Rwhere
Self: Sized,
F: FnMut(B, Self::Item) -> R,
R: Try<Output = B>,
1.27.0 · source§fn try_for_each<F, R>(&mut self, f: F) -> Rwhere
Self: Sized,
F: FnMut(Self::Item) -> R,
R: Try<Output = ()>,
fn try_for_each<F, R>(&mut self, f: F) -> Rwhere
Self: Sized,
F: FnMut(Self::Item) -> R,
R: Try<Output = ()>,
1.0.0 · source§fn fold<B, F>(self, init: B, f: F) -> Bwhere
Self: Sized,
F: FnMut(B, Self::Item) -> B,
fn fold<B, F>(self, init: B, f: F) -> Bwhere
Self: Sized,
F: FnMut(B, Self::Item) -> B,
1.51.0 · source§fn reduce<F>(self, f: F) -> Option<Self::Item>where
Self: Sized,
F: FnMut(Self::Item, Self::Item) -> Self::Item,
fn reduce<F>(self, f: F) -> Option<Self::Item>where
Self: Sized,
F: FnMut(Self::Item, Self::Item) -> Self::Item,
source§fn try_reduce<F, R>(
&mut self,
f: F
) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryTypewhere
Self: Sized,
F: FnMut(Self::Item, Self::Item) -> R,
R: Try<Output = Self::Item>,
<R as Try>::Residual: Residual<Option<Self::Item>>,
fn try_reduce<F, R>(
&mut self,
f: F
) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryTypewhere
Self: Sized,
F: FnMut(Self::Item, Self::Item) -> R,
R: Try<Output = Self::Item>,
<R as Try>::Residual: Residual<Option<Self::Item>>,
iterator_try_reduce)1.0.0 · source§fn all<F>(&mut self, f: F) -> boolwhere
Self: Sized,
F: FnMut(Self::Item) -> bool,
fn all<F>(&mut self, f: F) -> boolwhere
Self: Sized,
F: FnMut(Self::Item) -> bool,
1.0.0 · source§fn any<F>(&mut self, f: F) -> boolwhere
Self: Sized,
F: FnMut(Self::Item) -> bool,
fn any<F>(&mut self, f: F) -> boolwhere
Self: Sized,
F: FnMut(Self::Item) -> bool,
1.0.0 · source§fn find<P>(&mut self, predicate: P) -> Option<Self::Item>where
Self: Sized,
P: FnMut(&Self::Item) -> bool,
fn find<P>(&mut self, predicate: P) -> Option<Self::Item>where
Self: Sized,
P: FnMut(&Self::Item) -> bool,
1.30.0 · source§fn find_map<B, F>(&mut self, f: F) -> Option<B>where
Self: Sized,
F: FnMut(Self::Item) -> Option<B>,
fn find_map<B, F>(&mut self, f: F) -> Option<B>where
Self: Sized,
F: FnMut(Self::Item) -> Option<B>,
source§fn try_find<F, R>(
&mut self,
f: F
) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryTypewhere
Self: Sized,
F: FnMut(&Self::Item) -> R,
R: Try<Output = bool>,
<R as Try>::Residual: Residual<Option<Self::Item>>,
fn try_find<F, R>(
&mut self,
f: F
) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryTypewhere
Self: Sized,
F: FnMut(&Self::Item) -> R,
R: Try<Output = bool>,
<R as Try>::Residual: Residual<Option<Self::Item>>,
try_find)1.0.0 · source§fn position<P>(&mut self, predicate: P) -> Option<usize>where
Self: Sized,
P: FnMut(Self::Item) -> bool,
fn position<P>(&mut self, predicate: P) -> Option<usize>where
Self: Sized,
P: FnMut(Self::Item) -> bool,
1.6.0 · source§fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>where
B: Ord,
Self: Sized,
F: FnMut(&Self::Item) -> B,
fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>where
B: Ord,
Self: Sized,
F: FnMut(&Self::Item) -> B,
1.15.0 · source§fn max_by<F>(self, compare: F) -> Option<Self::Item>where
Self: Sized,
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
fn max_by<F>(self, compare: F) -> Option<Self::Item>where
Self: Sized,
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
1.6.0 · source§fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>where
B: Ord,
Self: Sized,
F: FnMut(&Self::Item) -> B,
fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>where
B: Ord,
Self: Sized,
F: FnMut(&Self::Item) -> B,
1.15.0 · source§fn min_by<F>(self, compare: F) -> Option<Self::Item>where
Self: Sized,
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
fn min_by<F>(self, compare: F) -> Option<Self::Item>where
Self: Sized,
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
1.0.0 · source§fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)where
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
Self: Sized + Iterator<Item = (A, B)>,
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)where
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
Self: Sized + Iterator<Item = (A, B)>,
1.36.0 · source§fn copied<'a, T>(self) -> Copied<Self>where
T: 'a + Copy,
Self: Sized + Iterator<Item = &'a T>,
fn copied<'a, T>(self) -> Copied<Self>where
T: 'a + Copy,
Self: Sized + Iterator<Item = &'a T>,
1.0.0 · source§fn cloned<'a, T>(self) -> Cloned<Self>where
T: 'a + Clone,
Self: Sized + Iterator<Item = &'a T>,
fn cloned<'a, T>(self) -> Cloned<Self>where
T: 'a + Clone,
Self: Sized + Iterator<Item = &'a T>,
1.0.0 · source§fn cycle(self) -> Cycle<Self>where
Self: Sized + Clone,
fn cycle(self) -> Cycle<Self>where
Self: Sized + Clone,
source§fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>where
Self: Sized,
fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>where
Self: Sized,
iter_array_chunks)N elements of the iterator at a time. Read more1.11.0 · source§fn sum<S>(self) -> Swhere
Self: Sized,
S: Sum<Self::Item>,
fn sum<S>(self) -> Swhere
Self: Sized,
S: Sum<Self::Item>,
1.11.0 · source§fn product<P>(self) -> Pwhere
Self: Sized,
P: Product<Self::Item>,
fn product<P>(self) -> Pwhere
Self: Sized,
P: Product<Self::Item>,
source§fn cmp_by<I, F>(self, other: I, cmp: F) -> Orderingwhere
Self: Sized,
I: IntoIterator,
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
fn cmp_by<I, F>(self, other: I, cmp: F) -> Orderingwhere
Self: Sized,
I: IntoIterator,
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
iter_order_by)Iterator with those
of another with respect to the specified comparison function. Read more1.5.0 · source§fn partial_cmp<I>(self, other: I) -> Option<Ordering>where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
Self: Sized,
fn partial_cmp<I>(self, other: I) -> Option<Ordering>where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
Self: Sized,
source§fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>where
Self: Sized,
I: IntoIterator,
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>where
Self: Sized,
I: IntoIterator,
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
iter_order_by)Iterator with those
of another with respect to the specified comparison function. Read more1.5.0 · source§fn eq<I>(self, other: I) -> boolwhere
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>,
Self: Sized,
fn eq<I>(self, other: I) -> boolwhere
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>,
Self: Sized,
source§fn eq_by<I, F>(self, other: I, eq: F) -> boolwhere
Self: Sized,
I: IntoIterator,
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
fn eq_by<I, F>(self, other: I, eq: F) -> boolwhere
Self: Sized,
I: IntoIterator,
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
iter_order_by)1.5.0 · source§fn ne<I>(self, other: I) -> boolwhere
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>,
Self: Sized,
fn ne<I>(self, other: I) -> boolwhere
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>,
Self: Sized,
1.5.0 · source§fn lt<I>(self, other: I) -> boolwhere
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
Self: Sized,
fn lt<I>(self, other: I) -> boolwhere
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
Self: Sized,
Iterator are lexicographically
less than those of another. Read more1.5.0 · source§fn le<I>(self, other: I) -> boolwhere
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
Self: Sized,
fn le<I>(self, other: I) -> boolwhere
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
Self: Sized,
Iterator are lexicographically
less or equal to those of another. Read more1.5.0 · source§fn gt<I>(self, other: I) -> boolwhere
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
Self: Sized,
fn gt<I>(self, other: I) -> boolwhere
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
Self: Sized,
Iterator are lexicographically
greater than those of another. Read more1.5.0 · source§fn ge<I>(self, other: I) -> boolwhere
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
Self: Sized,
fn ge<I>(self, other: I) -> boolwhere
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
Self: Sized,
Iterator are lexicographically
greater than or equal to those of another. Read moresource§fn is_sorted_by<F>(self, compare: F) -> boolwhere
Self: Sized,
F: FnMut(&Self::Item, &Self::Item) -> Option<Ordering>,
fn is_sorted_by<F>(self, compare: F) -> boolwhere
Self: Sized,
F: FnMut(&Self::Item, &Self::Item) -> Option<Ordering>,
is_sorted)source§fn is_sorted_by_key<F, K>(self, f: F) -> boolwhere
Self: Sized,
F: FnMut(Self::Item) -> K,
K: PartialOrd<K>,
fn is_sorted_by_key<F, K>(self, f: F) -> boolwhere
Self: Sized,
F: FnMut(Self::Item) -> K,
K: PartialOrd<K>,
is_sorted)Auto Trait Implementations§
impl RefUnwindSafe for StripedBitSource
impl !Send for StripedBitSource
impl !Sync for StripedBitSource
impl Unpin for StripedBitSource
impl UnwindSafe for StripedBitSource
Blanket Implementations§
source§impl<I> IntoIterator for Iwhere
I: Iterator,
impl<I> IntoIterator for Iwhere
I: Iterator,
source§impl<I> IteratorRandom for Iwhere
I: Iterator,
impl<I> IteratorRandom for Iwhere
I: Iterator,
source§fn 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,
source§impl<T> Itertools for Twhere
T: Iterator + ?Sized,
impl<T> Itertools for Twhere
T: Iterator + ?Sized,
source§fn interleave<J>(
self,
other: J
) -> Interleave<Self, <J as IntoIterator>::IntoIter>where
J: IntoIterator<Item = Self::Item>,
Self: Sized,
fn interleave<J>(
self,
other: J
) -> Interleave<Self, <J as IntoIterator>::IntoIter>where
J: IntoIterator<Item = Self::Item>,
Self: Sized,
source§fn interleave_shortest<J>(
self,
other: J
) -> InterleaveShortest<Self, <J as IntoIterator>::IntoIter>where
J: IntoIterator<Item = Self::Item>,
Self: Sized,
fn interleave_shortest<J>(
self,
other: J
) -> InterleaveShortest<Self, <J as IntoIterator>::IntoIter>where
J: IntoIterator<Item = Self::Item>,
Self: Sized,
source§fn intersperse(self, element: Self::Item) -> Intersperse<Self>where
Self: Sized,
Self::Item: Clone,
fn intersperse(self, element: Self::Item) -> Intersperse<Self>where
Self: Sized,
Self::Item: Clone,
source§fn zip_longest<J>(
self,
other: J
) -> ZipLongest<Self, <J as IntoIterator>::IntoIter>where
J: IntoIterator,
Self: Sized,
fn zip_longest<J>(
self,
other: J
) -> ZipLongest<Self, <J as IntoIterator>::IntoIter>where
J: IntoIterator,
Self: Sized,
source§fn zip_eq<J>(self, other: J) -> ZipEq<Self, <J as IntoIterator>::IntoIter>where
J: IntoIterator,
Self: Sized,
fn zip_eq<J>(self, other: J) -> ZipEq<Self, <J as IntoIterator>::IntoIter>where
J: IntoIterator,
Self: Sized,
source§fn batching<B, F>(self, f: F) -> Batching<Self, F>where
F: FnMut(&mut Self) -> Option<B>,
Self: Sized,
fn batching<B, F>(self, f: F) -> Batching<Self, F>where
F: FnMut(&mut Self) -> Option<B>,
Self: Sized,
source§fn group_by<K, F>(self, key: F) -> GroupBy<K, Self, F>where
Self: Sized,
F: FnMut(&Self::Item) -> K,
K: PartialEq<K>,
fn group_by<K, F>(self, key: F) -> GroupBy<K, Self, F>where
Self: Sized,
F: FnMut(&Self::Item) -> K,
K: PartialEq<K>,
source§fn chunks(self, size: usize) -> IntoChunks<Self>where
Self: Sized,
fn chunks(self, size: usize) -> IntoChunks<Self>where
Self: Sized,
source§fn tuple_windows<T>(self) -> TupleWindows<Self, T>where
Self: Sized + Iterator<Item = <T as TupleCollect>::Item>,
T: HomogeneousTuple,
<T as TupleCollect>::Item: Clone,
fn tuple_windows<T>(self) -> TupleWindows<Self, T>where
Self: Sized + Iterator<Item = <T as TupleCollect>::Item>,
T: HomogeneousTuple,
<T as TupleCollect>::Item: Clone,
source§fn tuples<T>(self) -> Tuples<Self, T>where
Self: Sized + Iterator<Item = <T as TupleCollect>::Item>,
T: HomogeneousTuple,
fn tuples<T>(self) -> Tuples<Self, T>where
Self: Sized + Iterator<Item = <T as TupleCollect>::Item>,
T: HomogeneousTuple,
source§fn tee(self) -> (Tee<Self>, Tee<Self>)where
Self: Sized,
Self::Item: Clone,
fn tee(self) -> (Tee<Self>, Tee<Self>)where
Self: Sized,
Self::Item: Clone,
source§fn step(self, n: usize) -> Step<Self>where
Self: Sized,
fn step(self, n: usize) -> Step<Self>where
Self: Sized,
n elements in the base iterator
for each iteration. Read moresource§fn map_into<R>(self) -> MapInto<Self, R>where
Self: Sized,
Self::Item: Into<R>,
fn map_into<R>(self) -> MapInto<Self, R>where
Self: Sized,
Self::Item: Into<R>,
Into trait. Read moresource§fn map_results<F, T, U, E>(self, f: F) -> MapResults<Self, F>where
Self: Iterator<Item = Result<T, E>> + Sized,
F: FnMut(T) -> U,
fn map_results<F, T, U, E>(self, f: F) -> MapResults<Self, F>where
Self: Iterator<Item = Result<T, E>> + Sized,
F: FnMut(T) -> U,
Result::Ok value. Result::Err values are
unchanged. Read moresource§fn merge<J>(
self,
other: J
) -> MergeBy<Self, <J as IntoIterator>::IntoIter, MergeLte>where
Self: Sized,
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: Sized,
Self::Item: PartialOrd<Self::Item>,
J: IntoIterator<Item = Self::Item>,
source§fn merge_by<J, F>(
self,
other: J,
is_first: F
) -> MergeBy<Self, <J as IntoIterator>::IntoIter, F>where
Self: Sized,
J: IntoIterator<Item = Self::Item>,
F: FnMut(&Self::Item, &Self::Item) -> bool,
fn merge_by<J, F>(
self,
other: J,
is_first: F
) -> MergeBy<Self, <J as IntoIterator>::IntoIter, F>where
Self: Sized,
J: IntoIterator<Item = Self::Item>,
F: FnMut(&Self::Item, &Self::Item) -> bool,
.merge() but allows for a custom ordering. Read moresource§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,
Self: Sized,
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,
Self: Sized,
source§fn kmerge(self) -> KMergeBy<<Self::Item as IntoIterator>::IntoIter, KMergeByLt>where
Self: Sized,
Self::Item: IntoIterator,
<Self::Item as IntoIterator>::Item: PartialOrd<<Self::Item as IntoIterator>::Item>,
fn kmerge(self) -> KMergeBy<<Self::Item as IntoIterator>::IntoIter, KMergeByLt>where
Self: Sized,
Self::Item: IntoIterator,
<Self::Item as IntoIterator>::Item: PartialOrd<<Self::Item as IntoIterator>::Item>,
source§fn kmerge_by<F>(
self,
first: F
) -> KMergeBy<<Self::Item as IntoIterator>::IntoIter, F>where
Self: Sized,
Self::Item: IntoIterator,
F: FnMut(&<Self::Item as IntoIterator>::Item, &<Self::Item as IntoIterator>::Item) -> bool,
fn kmerge_by<F>(
self,
first: F
) -> KMergeBy<<Self::Item as IntoIterator>::IntoIter, F>where
Self: Sized,
Self::Item: IntoIterator,
F: FnMut(&<Self::Item as IntoIterator>::Item, &<Self::Item as IntoIterator>::Item) -> bool,
source§fn cartesian_product<J>(
self,
other: J
) -> Product<Self, <J as IntoIterator>::IntoIter>where
Self: Sized,
Self::Item: Clone,
J: IntoIterator,
<J as IntoIterator>::IntoIter: Clone,
fn cartesian_product<J>(
self,
other: J
) -> Product<Self, <J as IntoIterator>::IntoIter>where
Self: Sized,
Self::Item: Clone,
J: IntoIterator,
<J as IntoIterator>::IntoIter: Clone,
self and J. Read moresource§fn multi_cartesian_product(
self
) -> MultiProduct<<Self::Item as IntoIterator>::IntoIter>where
Self: Iterator + Sized,
Self::Item: IntoIterator,
<Self::Item as IntoIterator>::IntoIter: Clone,
<Self::Item as IntoIterator>::Item: Clone,
fn multi_cartesian_product(
self
) -> MultiProduct<<Self::Item as IntoIterator>::IntoIter>where
Self: Iterator + Sized,
Self::Item: IntoIterator,
<Self::Item as IntoIterator>::IntoIter: Clone,
<Self::Item as IntoIterator>::Item: Clone,
self. Read moresource§fn coalesce<F>(self, f: F) -> Coalesce<Self, F>where
Self: Sized,
F: FnMut(Self::Item, Self::Item) -> Result<Self::Item, (Self::Item, Self::Item)>,
fn coalesce<F>(self, f: F) -> Coalesce<Self, F>where
Self: Sized,
F: FnMut(Self::Item, Self::Item) -> Result<Self::Item, (Self::Item, Self::Item)>,
source§fn dedup(self) -> DedupBy<Self, DedupEq>where
Self: Sized,
Self::Item: PartialEq<Self::Item>,
fn dedup(self) -> DedupBy<Self, DedupEq>where
Self: Sized,
Self::Item: PartialEq<Self::Item>,
source§fn dedup_by<Cmp>(self, cmp: Cmp) -> DedupBy<Self, Cmp>where
Self: Sized,
Cmp: FnMut(&Self::Item, &Self::Item) -> bool,
fn dedup_by<Cmp>(self, cmp: Cmp) -> DedupBy<Self, Cmp>where
Self: Sized,
Cmp: FnMut(&Self::Item, &Self::Item) -> bool,
source§fn unique(self) -> Unique<Self>where
Self: Sized,
Self::Item: Clone + Eq + Hash,
fn unique(self) -> Unique<Self>where
Self: Sized,
Self::Item: Clone + Eq + Hash,
source§fn unique_by<V, F>(self, f: F) -> UniqueBy<Self, V, F>where
Self: Sized,
V: Eq + Hash,
F: FnMut(&Self::Item) -> V,
fn unique_by<V, F>(self, f: F) -> UniqueBy<Self, V, F>where
Self: Sized,
V: Eq + Hash,
F: FnMut(&Self::Item) -> V,
source§fn peeking_take_while<F>(&mut self, accept: F) -> PeekingTakeWhile<'_, Self, F>where
Self: Sized + PeekingNext,
F: FnMut(&Self::Item) -> bool,
fn peeking_take_while<F>(&mut self, accept: F) -> PeekingTakeWhile<'_, Self, F>where
Self: Sized + PeekingNext,
F: FnMut(&Self::Item) -> bool,
accept returns true. Read moresource§fn take_while_ref<F>(&mut self, accept: F) -> TakeWhileRef<'_, Self, F>where
Self: Clone,
F: FnMut(&Self::Item) -> bool,
fn take_while_ref<F>(&mut self, accept: F) -> TakeWhileRef<'_, Self, F>where
Self: Clone,
F: FnMut(&Self::Item) -> bool,
Clone-able iterator
to only pick off elements while the predicate accept returns true. Read moresource§fn while_some<A>(self) -> WhileSome<Self>where
Self: Sized + Iterator<Item = Option<A>>,
fn while_some<A>(self) -> WhileSome<Self>where
Self: Sized + Iterator<Item = Option<A>>,
Option<A> iterator elements
and produces A. Stops on the first None encountered. Read moresource§fn tuple_combinations<T>(self) -> TupleCombinations<Self, T>where
Self: Sized + Clone,
Self::Item: Clone,
T: HasCombination<Self>,
fn tuple_combinations<T>(self) -> TupleCombinations<Self, T>where
Self: Sized + Clone,
Self::Item: Clone,
T: HasCombination<Self>,
source§fn combinations(self, k: usize) -> Combinations<Self>where
Self: Sized,
Self::Item: Clone,
fn combinations(self, k: usize) -> Combinations<Self>where
Self: Sized,
Self::Item: Clone,
k-length combinations of
the elements from an iterator. Read moresource§fn combinations_with_replacement(
self,
k: usize
) -> CombinationsWithReplacement<Self>where
Self: Sized,
Self::Item: Clone,
fn combinations_with_replacement(
self,
k: usize
) -> CombinationsWithReplacement<Self>where
Self: Sized,
Self::Item: Clone,
k-length combinations of
the elements from an iterator, with replacement. Read moresource§fn permutations(self, k: usize) -> Permutations<Self>where
Self: Sized,
Self::Item: Clone,
fn permutations(self, k: usize) -> Permutations<Self>where
Self: Sized,
Self::Item: Clone,
source§fn pad_using<F>(self, min: usize, f: F) -> PadUsing<Self, F>where
Self: Sized,
F: FnMut(usize) -> Self::Item,
fn pad_using<F>(self, min: usize, f: F) -> PadUsing<Self, F>where
Self: Sized,
F: FnMut(usize) -> Self::Item,
min by filling missing elements using a closure f. Read moresource§fn with_position(self) -> WithPosition<Self>where
Self: Sized,
fn with_position(self) -> WithPosition<Self>where
Self: Sized,
Position to
ease special-case handling of the first or last elements. Read moresource§fn positions<P>(self, predicate: P) -> Positions<Self, P>where
Self: Sized,
P: FnMut(Self::Item) -> bool,
fn positions<P>(self, predicate: P) -> Positions<Self, P>where
Self: Sized,
P: FnMut(Self::Item) -> bool,
source§fn update<F>(self, updater: F) -> Update<Self, F>where
Self: Sized,
F: FnMut(&mut Self::Item),
fn update<F>(self, updater: F) -> Update<Self, F>where
Self: Sized,
F: FnMut(&mut Self::Item),
source§fn next_tuple<T>(&mut self) -> Option<T>where
Self: Sized + Iterator<Item = <T as TupleCollect>::Item>,
T: HomogeneousTuple,
fn next_tuple<T>(&mut self) -> Option<T>where
Self: Sized + Iterator<Item = <T as TupleCollect>::Item>,
T: HomogeneousTuple,
source§fn collect_tuple<T>(self) -> Option<T>where
Self: Sized + Iterator<Item = <T as TupleCollect>::Item>,
T: HomogeneousTuple,
fn collect_tuple<T>(self) -> Option<T>where
Self: Sized + Iterator<Item = <T as TupleCollect>::Item>,
T: HomogeneousTuple,
source§fn find_position<P>(&mut self, pred: P) -> Option<(usize, Self::Item)>where
P: FnMut(&Self::Item) -> bool,
fn find_position<P>(&mut self, pred: P) -> Option<(usize, Self::Item)>where
P: FnMut(&Self::Item) -> bool,
source§fn all_equal(&mut self) -> boolwhere
Self: Sized,
Self::Item: PartialEq<Self::Item>,
fn all_equal(&mut self) -> boolwhere
Self: Sized,
Self::Item: PartialEq<Self::Item>,
source§fn dropping(self, n: usize) -> Selfwhere
Self: Sized,
fn dropping(self, n: usize) -> Selfwhere
Self: Sized,
n elements from the iterator eagerly,
and return the same iterator again. Read moresource§fn dropping_back(self, n: usize) -> Selfwhere
Self: Sized + DoubleEndedIterator,
fn dropping_back(self, n: usize) -> Selfwhere
Self: Sized + DoubleEndedIterator,
n elements from the iterator eagerly,
and return the same iterator again. Read moresource§fn foreach<F>(self, f: F)where
F: FnMut(Self::Item),
Self: Sized,
fn foreach<F>(self, f: F)where
F: FnMut(Self::Item),
Self: Sized,
f eagerly on each element of the iterator. Read moresource§fn concat(self) -> Self::Itemwhere
Self: Sized,
Self::Item: Extend<<Self::Item as IntoIterator>::Item> + IntoIterator + Default,
fn concat(self) -> Self::Itemwhere
Self: Sized,
Self::Item: Extend<<Self::Item as IntoIterator>::Item> + IntoIterator + Default,
Extend. Read moresource§fn collect_vec(self) -> Vec<Self::Item, Global>where
Self: Sized,
fn collect_vec(self) -> Vec<Self::Item, Global>where
Self: Sized,
.collect_vec() is simply a type specialization of .collect(),
for convenience.source§fn try_collect<T, U, E>(self) -> Result<U, E>where
Self: Sized + Iterator<Item = Result<T, E>>,
Result<U, E>: FromIterator<Result<T, E>>,
fn try_collect<T, U, E>(self) -> Result<U, E>where
Self: Sized + Iterator<Item = Result<T, E>>,
Result<U, E>: FromIterator<Result<T, E>>,
source§fn set_from<'a, A, J>(&mut self, from: J) -> usizewhere
A: 'a,
Self: Iterator<Item = &'a mut A>,
J: IntoIterator<Item = A>,
fn set_from<'a, A, J>(&mut self, from: J) -> usizewhere
A: 'a,
Self: Iterator<Item = &'a mut A>,
J: IntoIterator<Item = A>,
self from the from iterator,
stopping at the shortest of the two iterators. Read moresource§fn join(&mut self, sep: &str) -> Stringwhere
Self::Item: Display,
fn join(&mut self, sep: &str) -> Stringwhere
Self::Item: Display,
sep. Read moresource§fn format(self, sep: &str) -> Format<'_, Self>where
Self: Sized,
fn format(self, sep: &str) -> Format<'_, Self>where
Self: Sized,
sep. Read moresource§fn format_with<F>(self, sep: &str, format: F) -> FormatWith<'_, Self, F>where
Self: Sized,
F: FnMut(Self::Item, &mut dyn FnMut(&dyn Display) -> Result<(), Error>) -> Result<(), Error>,
fn format_with<F>(self, sep: &str, format: F) -> FormatWith<'_, Self, F>where
Self: Sized,
F: FnMut(Self::Item, &mut dyn FnMut(&dyn Display) -> Result<(), Error>) -> Result<(), Error>,
sep. Read moresource§fn fold_results<A, E, B, F>(&mut self, start: B, f: F) -> Result<B, E>where
Self: Iterator<Item = Result<A, E>>,
F: FnMut(B, A) -> B,
fn fold_results<A, E, B, F>(&mut self, start: B, f: F) -> Result<B, E>where
Self: Iterator<Item = Result<A, E>>,
F: FnMut(B, A) -> B,
Result values from an iterator. Read moresource§fn fold_options<A, B, F>(&mut self, start: B, f: F) -> Option<B>where
Self: Iterator<Item = Option<A>>,
F: FnMut(B, A) -> B,
fn fold_options<A, B, F>(&mut self, start: B, f: F) -> Option<B>where
Self: Iterator<Item = Option<A>>,
F: FnMut(B, A) -> B,
Option values from an iterator. Read moresource§fn fold1<F>(self, f: F) -> Option<Self::Item>where
F: FnMut(Self::Item, Self::Item) -> Self::Item,
Self: Sized,
fn fold1<F>(self, f: F) -> Option<Self::Item>where
F: FnMut(Self::Item, Self::Item) -> Self::Item,
Self: Sized,
source§fn tree_fold1<F>(self, f: F) -> Option<Self::Item>where
F: FnMut(Self::Item, Self::Item) -> Self::Item,
Self: Sized,
fn tree_fold1<F>(self, f: F) -> Option<Self::Item>where
F: FnMut(Self::Item, Self::Item) -> Self::Item,
Self: Sized,
source§fn fold_while<B, F>(&mut self, init: B, f: F) -> FoldWhile<B>where
Self: Sized,
F: FnMut(B, Self::Item) -> FoldWhile<B>,
fn fold_while<B, F>(&mut self, init: B, f: F) -> FoldWhile<B>where
Self: Sized,
F: FnMut(B, Self::Item) -> FoldWhile<B>,
source§fn sum1<S>(self) -> Option<S>where
Self: Sized,
S: Sum<Self::Item>,
fn sum1<S>(self) -> Option<S>where
Self: Sized,
S: Sum<Self::Item>,
source§fn product1<P>(self) -> Option<P>where
Self: Sized,
P: Product<Self::Item>,
fn product1<P>(self) -> Option<P>where
Self: Sized,
P: Product<Self::Item>,
source§fn sorted(self) -> IntoIter<Self::Item, Global>where
Self: Sized,
Self::Item: Ord,
fn sorted(self) -> IntoIter<Self::Item, Global>where
Self: Sized,
Self::Item: Ord,
source§fn sorted_by<F>(self, cmp: F) -> IntoIter<Self::Item, Global>where
Self: Sized,
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
fn sorted_by<F>(self, cmp: F) -> IntoIter<Self::Item, Global>where
Self: Sized,
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
source§fn sorted_by_key<K, F>(self, f: F) -> IntoIter<Self::Item, Global>where
Self: Sized,
K: Ord,
F: FnMut(&Self::Item) -> K,
fn sorted_by_key<K, F>(self, f: F) -> IntoIter<Self::Item, Global>where
Self: Sized,
K: Ord,
F: FnMut(&Self::Item) -> K,
source§fn partition_map<A, B, F, L, R>(self, predicate: F) -> (A, B)where
Self: Sized,
F: FnMut(Self::Item) -> Either<L, R>,
A: Default + Extend<L>,
B: Default + Extend<R>,
fn partition_map<A, B, F, L, R>(self, predicate: F) -> (A, B)where
Self: Sized,
F: FnMut(Self::Item) -> Either<L, R>,
A: Default + Extend<L>,
B: Default + Extend<R>,
Iterator::partition, each partition may
have a distinct type. Read moresource§fn into_group_map<K, V>(self) -> HashMap<K, Vec<V, Global>, RandomState>where
Self: Iterator<Item = (K, V)> + Sized,
K: Hash + Eq,
fn into_group_map<K, V>(self) -> HashMap<K, Vec<V, Global>, RandomState>where
Self: Iterator<Item = (K, V)> + Sized,
K: Hash + Eq,
HashMap of keys mapped to Vecs of values. Keys and values
are taken from (Key, Value) tuple pairs yielded by the input iterator. Read more