simple_scan 0.4.0

Iterator extensions for simple scan operation.
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
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99

simple_scan
===

`Iterator` extensions for simple scan operation.

*The author of this crate is not good at English.*  
*Forgive me if the document is hard to read.*

## What is this?


This crate provides the `IteratorSimpleScanExt` trait.
The `IteratorSimpleScanExt` trait is an extension trait of the `Iterator` trait,
which implements some methods similar to the `scan` methods of the `Iterator`
trait, but more simplified and specialized.

The following is a list of those methods. The sample code on the left shows the
case where those simplified methods are used, and the sample code on the right
shows the case where the same process is implemented with `scan` method.

<table>
<thead>
<tr>
<th>Name
<th>example / equivalent code
<tbody valign="baseline">
<tr>
<td> <code>trace</code>
<td>

```rust
(0..10).trace(0, |s, x| s + x)
```

```rust
(0..10).scan(0, |s, x| {
    *s += x;
    Some(*s)
});
```

<tr>
<td> <code>trace2</code>
<td>

```rust
(0..10).trace2(0, |s, x| s + x)
```

```rust
(0..10).scan(0, |s, x| {
    let prev = *s;
    *s += x;
    Some((prev, *s))
});
```

<tr>
<td><code>diff</code>

<td>

```rust
(0..10).diff(0, |c, p| c - p)
```

```rust
(0..10).scan(0, |s, x| {
    let p = mem::replace(s, x);
    Some(x - p)
});
```

</table>

## What's New


v0.4.0
* Rust edition is updated to 2024.
* Add `prelude` module (Although this crate is very small).
* Polish documentations.

v0.3.1

* Minor refactoring.

v0.3.0

* `must_use` annotations are added at several locations.

v0.2.1

* Minor refactoring.

v0.2.0

* changes `trace2` behavior.
  
  In version 0.2, it track previous and current state.  
  While in version 0.1, it track current state and current input.