Crate iter_accumulate 

This crate provides accumulate, an iterator adaptor that accumulates the elements from the base iterator using the provided closure.

accumulate takes two arguments: an initial value, and a closure with two arguments: an ‘accumulator’, and an element.

The initial value is the value the accumulator will have when the closure is first called. On each call to Iterator::next, the closure is executed with the current accumulator and the element yielded by the upstream iterator. The return value of the closure is then set as the new value of the accumulator and returned to the caller.

Since the accumulated value needs to be both stored as the accumulator and returned to the caller, the accumulator type must implement Copy. If you want to operate on non-copyable types, you should use Iterator::scan instead.

The returned iterator is not fused and it is not specified what happens when the base iterator returns None. If you want a fused iterator, use Iterator::fuse.

Differences to Iterator::fold

In principle, accumulate is similar to Iterator::fold. However, instead of returning the final accumulated result, it returns an iterator that yields the current value of the accumulator for each iteration. In other words, the last element yielded by accumulate is what would have been returned by Iterator::fold if it had been used instead.

Examples

use iter_accumulate::IterAccumulate;

let input = [1, 2, 3, 4, 5];
let mut iter = input.iter().accumulate(1, |acc, i| acc * i);

assert_eq!(iter.next(), Some(1));
assert_eq!(iter.next(), Some(2));
assert_eq!(iter.next(), Some(6));
assert_eq!(iter.next(), Some(24));
assert_eq!(iter.next(), Some(120));
assert_eq!(iter.next(), None);

Structs

Accumulate

An iterator adaptor that accumulates the elements from the base iterator using the provided closure.

Traits

IterAccumulate

An Iterator blanket implementation that provides the accumulate function.