pipx 0.1.0

Composable pipelines for Rust with synchronous and asynchronous execution, middleware-style processing, and predictable data flow.
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

/// Error types and utilities.
pub mod errors;

/// Declarative macros for pipeline construction.
pub mod macros;

/// Pipeline step traits and continuations.
pub mod pipe;

/// Pipeline implementations and helpers.
pub mod pipeline;

/// Shared pipeline type aliases.
pub mod types;

/// Re-export error types and utilities.
pub use crate::errors::*;

/// Re-export pipeline step traits and continuations.
pub use crate::pipe::*;

/// Re-export pipeline implementations and helpers.
pub use crate::pipeline::*;

/// Re-export shared pipeline type aliases.
pub use crate::types::*;

#[cfg(feature = "macros")]
pub use pipx_macros::pipe;

/// Creates a pipeline with an initial value.
///
/// **Parameters**
/// - `passable` - The value that should be processed by the pipeline.
///
/// **Returns**
/// - [`Pipeline`] - A pipeline instance with the provided value set.
pub fn pipeline<TPassable>(passable: TPassable) -> Pipeline<TPassable> {
    Pipeline::new().send(passable)
}

/// Creates an asynchronous pipeline with an initial value.
///
/// **Parameters**
/// - `passable` - The value that should be processed by the asynchronous pipeline.
///
/// **Returns**
/// - [`AsyncPipeline`] - An asynchronous pipeline instance with the provided value set.
#[cfg(feature = "async")]
pub fn async_pipeline<TPassable>(passable: TPassable) -> AsyncPipeline<TPassable> {
    AsyncPipeline::new().send(passable)
}