iter_seq 0.2.0

Stateless, transformable, abstract sequence of values
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

# iter_seq


Stateless, transformable, abstract sequence of values.

This crate provides a mechanism for working with abstract *stateless*
sequences of arbitrary values. In contrast, standard iterators are
stateful—that is, their state can be changed by calling `next`.

One significant limitation of the stateful model is its inability to encode
compile-time invariants, which can lead to unnecessary overhead that
the compiler often cannot reliably optimize away. This crate provides
a "wrapper" around standard iterators that must be irreversibly
converted into an iterator before its elements can be consumed.

# Example


```rust
use iter_seq::{Sequence, repeat};

fn main() {
    let odd_squares = repeat(())
        .enumerate()
        .map(|(i, _)| i as u32)
        .map(|n| (n + 1) * (n + 1));

    let arr: [u32; 128] = odd_squares.take_exact_s::<128>()
        .collect_array();

    for (i, n) in arr.iter().enumerate() {
        assert_eq!((i as u32 + 1) * (i as u32 + 1), *n);
    }
}
```