unipipe-macros 0.3.1

A simple Rust pipe abstraction that extends to iterator and stream.
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
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116

# UniPipe

![Crates.io License](https://img.shields.io/crates/l/unipipe?style=flat-square)
![Crates.io Version](https://img.shields.io/crates/v/unipipe?style=flat-square)

A simple Rust pipe abstraction that extends to iterator and stream.

## Installation

```sh
cargo add unipipe
```

## Usage

```rust
use unipipe::{Output, UniPipe, unipipe};

pub struct MyPipe {
    state: u32,
}

impl UniPipe for MyPipe {
    type Input = u32;
    type Output = u32;

    fn next(&mut self, input: Option<Self::Input>) -> Output<Self::Output> {
        if let Some(input) = input {
            self.state += input;
            Some(self.state)
        } else {
            // Returning `None` does not indicate the end of the pipe,
            // use `Output::Done` instead.
            None
        }
        .into()
    }
}

#[unipipe(iterator, try_iterator, stream, try_stream)]
impl MyPipe {
    // - my_pipe()
    // - try_my_pipe()
    pub fn new() -> Self {
        Self { state: 0 }
    }

    // - my_pipe_with_state(state)
    // - try_my_pipe_with_state(state)
    pub fn new_with_state(state: u32) -> Self {
        Self { state }
    }

    // - custom_pipe()
    // - try_custom_pipe()
    pub fn custom_pipe() -> Self {
        Self { state: 0 }
    }
}
```

To use generated methods from other files, you need to import the generated traits accordingly.

```rust
use my_pipe::MyPipeUniPipeIteratorExt as _;

let mut iter = vec![1, 2, 3, 4, 5].into_iter().my_pipe();
```

### Output

`Output` is the "final" return type of `UniPipe::next()`. It can be one of the following:

- `Output::Next` - equivalent to `Option::None`
- `Output::One(value)` - equivalent to `Option::Some(value)`
- `Output::Many(values)`
- `Output::Done`
- `Output::DoneWithOne(value)`
- `Output::DoneWithMany(values)`

#### Map `Output`

`Output::map()` is a method that allows you to transform the value of the `Output` without changing the structure of the `Output`.

```rust
impl UniPipe for OuterPipe {
    type Input = i32;
    type Output = i32;

    fn next(&mut self, input: Option<Self::Input>) -> Output<Self::Output> {
        self.inner.next(input).map(|output| -output)
    }
}
```

#### Pipe `Output`

`Output::pipe()` is a method that allows you to pipe the `Output` to another `UniPipe`.

```rust
impl UniPipe for ComposePipe {
    type Input = i32;
    type Output = i32;

    fn next(&mut self, input: Option<Self::Input>) -> Output<Self::Output> {
        self.first
            .next(input)
            .pipe(&mut self.second)
            .pipe(&mut self.third)
    }
}
```

## License

This project is licensed under the MIT License.