rustmax 0.0.11

A collection of useful crates.
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
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

Extra iterator methods and utilities.

- Crate [`::itertools`].
- [docs.rs](https://docs.rs/itertools)
- [crates.io](https://crates.io/crates/itertools)
- [GitHub](https://github.com/rust-itertools/itertools)

---

`itertools` extends Rust's iterator functionality with a rich collection
of additional iterator methods and utilities.

The crate provides the [`Itertools`] trait that adds dozens of useful methods
to any iterator, enabling powerful functional programming patterns.
It includes methods for grouping, batching, sorting, deduplication,
and complex iteration patterns that would otherwise require verbose loops.

Key features include [`chunk_by`] for grouping consecutive elements,
[`chunk`] for batching elements into fixed-size groups,
[`sorted`] for sorting without collecting first,
[`dedup`] for removing duplicates,
[`intersperse`] for inserting separators,
and [`cartesian_product`] for combining iterators.

The crate also provides standalone functions like [`zip_eq`] for
strict zipping that panics on length mismatches,
and [`repeat_n`] for creating repeating sequences.

## Examples

Grouping consecutive elements:

```rust
use itertools::Itertools;

let data = vec![1, 1, 2, 2, 2, 3, 1, 1];
let groups: Vec<_> = data
    .into_iter()
    .chunk_by(|&x| x)
    .into_iter()
    .map(|(key, group)| (key, group.count()))
    .collect();

assert_eq!(groups, [(1, 2), (2, 3), (3, 1), (1, 2)]);
```

Batching and processing in chunks:

```rust
use itertools::Itertools;

let data = 1..=10;
let chunks: Vec<Vec<_>> = data.chunks(3).into_iter().map(|chunk| chunk.collect()).collect();

assert_eq!(chunks, [vec![1, 2, 3], vec![4, 5, 6], vec![7, 8, 9], vec![10]]);
```

Combining iterators with cartesian product:

```rust
use itertools::Itertools;

let coords: Vec<_> = (0..3)
    .cartesian_product(0..3)
    .collect();

assert_eq!(coords.len(), 9);
assert_eq!(coords[0], (0, 0));
assert_eq!(coords[8], (2, 2));
```

[`Itertools`]: crate::itertools::Itertools
[`chunk_by`]: crate::itertools::Itertools::chunk_by
[`chunk`]: crate::itertools::Itertools::chunks
[`sorted`]: crate::itertools::Itertools::sorted
[`dedup`]: crate::itertools::Itertools::dedup
[`intersperse`]: crate::itertools::Itertools::intersperse
[`cartesian_product`]: crate::itertools::Itertools::cartesian_product
[`zip_eq`]: crate::itertools::zip_eq
[`repeat_n`]: crate::itertools::repeat_n