iter_accumulate

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

Example

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);

License

Licensed under either of

• Apache License, Version 2.0 (LICENSE-APACHE or https://www.apache.org/licenses/LICENSE-2.0)
• MIT license (LICENSE-MIT or https://opensource.org/licenses/MIT)

at your option.

Contribution

Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.

lib.rs:

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 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 Clone.

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 fuse().

Differences to fold()

In principle, accumulate() is similar to 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 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);