pub struct Unfold<St, F> {
pub state: St,
// some fields omitted
}
Unfold
is a general iterator builder: it has a mutable state value,
and a closure with access to the state that produces the next value.
This more or less equivalent to a regular struct with an Iterator
implementation, and is useful for one-off iterators.
use itertools::Unfold;
let mut fibonacci = Unfold::new((1_u32, 1_u32), |state| {
let (ref mut x1, ref mut x2) = *state;
let next = x1.saturating_add(*x2);
let ret = *x1;
*x1 = *x2;
*x2 = next;
if ret == *x1 && ret > 1 {
return None;
}
Some(ret)
});
itertools::assert_equal(fibonacci.by_ref().take(8),
vec![1, 1, 2, 3, 5, 8, 13, 21]);
assert_eq!(fibonacci.last(), Some(2_971_215_073))
Fields
state | Internal state that will be passed to the closure on the next iteration
|
Methods
impl<A, St, F> Unfold<St, F> where F: FnMut(&mut St) -> Option<A>
fn new(initial_state: St, f: F) -> Unfold<St, F>
[−]
Creates a new iterator with the specified closure as the "iterator
function" and an initial state to eventually pass to the closure
Trait Implementations
impl<A, St, F> Iterator for Unfold<St, F> where F: FnMut(&mut St) -> Option<A>
type Item = A
fn next(&mut self) -> Option<A>
1.0.0fn map<B, F>(self, f: F) -> Map<Self, F> where F: FnMut(Self::Item) -> B
1.0.0fn filter<P>(self, predicate: P) -> Filter<Self, P> where P: FnMut(&Self::Item) -> bool
1.0.0fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P> where P: FnMut(&Self::Item) -> bool
1.0.0fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P> where P: FnMut(&Self::Item) -> bool
1.0.0fn skip(self, n: usize) -> Skip<Self>
1.0.0fn take(self, n: usize) -> Take<Self>
1.0.0fn 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.0fn fuse(self) -> Fuse<Self>
1.0.0fn inspect<F>(self, f: F) -> Inspect<Self, F> where F: FnMut(&Self::Item) -> ()
1.0.0fn by_ref(&mut self) -> &mut Self
1.0.0fn fold<B, F>(self, init: B, f: F) -> B where F: FnMut(B, Self::Item) -> B
1.0.0fn all<F>(&mut self, f: F) -> bool where F: FnMut(Self::Item) -> bool
1.0.0fn any<F>(&mut self, f: F) -> bool where F: FnMut(Self::Item) -> bool
1.0.0fn find<P>(&mut self, predicate: P) -> Option<Self::Item> where P: FnMut(&Self::Item) -> bool
1.0.0fn max(self) -> Option<Self::Item> where Self::Item: Ord
1.0.0fn min(self) -> Option<Self::Item> where Self::Item: Ord
fn max_by<B, F>(self, f: F) -> Option<Self::Item> where F: FnMut(&Self::Item) -> B, B: Ord
1.6.0fn max_by_key<B, F>(self, f: F) -> Option<Self::Item> where B: Ord, F: FnMut(&Self::Item) -> B
fn min_by<B, F>(self, f: F) -> Option<Self::Item> where F: FnMut(&Self::Item) -> B, B: Ord
1.6.0fn min_by_key<B, F>(self, f: F) -> Option<Self::Item> where F: FnMut(&Self::Item) -> B, B: Ord
1.0.0fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where Self: Iterator<Item=(A, B)>, FromB: Default + Extend<B>, FromA: Default + Extend<A>
1.0.0fn cloned<'a, T>(self) -> Cloned<Self> where Self: Iterator<Item=&'a T>, T: 'a + Clone
1.0.0fn cycle(self) -> Cycle<Self> where Self: Clone
fn sum<S>(self) -> S where S: Add<Self::Item, Output=S> + Zero
fn product<P>(self) -> P where P: Mul<Self::Item, Output=P> + One
Derived Implementations