id_effect 0.2.0

Effect<A, E, R> (sync + async), context/layers, pipe — interpreter-style, no bundled executor
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

//! **Stratum 1: Algebraic Structures** — abstract patterns that recur throughout the system.
//!
//! This module provides the fundamental algebraic abstractions built on top of
//! [Stratum 0 foundations](super::foundation). These structures capture common
//! patterns of composition, transformation, and combination.
//!
//! ## Hierarchy
//!
//! ```text
//!                    Semigroup
//!                        │
//!                        ▼
//!                     Monoid
//!
//!     Contravariant   Functor   Bifunctor
//!                        │
//!                        ▼
//!                   Applicative
//!                        │
//!                        ▼
//!                      Monad
//! ```
//!
//! ## Design Notes
//!
//! Rust lacks higher-kinded types, so we use two complementary approaches:
//!
//! 1. **Traits with associated types** — for types with a single "mappable" parameter
//! 2. **Module functions** — for operations on concrete types (like `Option`, `Result`)
//!
//! The traits express the *structure*, while module functions provide ergonomic usage.

pub mod applicative;
pub mod bifunctor;
pub mod contravariant;
pub mod functor;
pub mod interface;
pub mod monad;
pub mod monoid;
pub mod selective;
pub mod semigroup;

pub use applicative::Applicative;
pub use bifunctor::Bifunctor;
pub use contravariant::Contravariant;
pub use functor::Functor;
pub use monad::Monad;
pub use monoid::Monoid;
pub use selective::Selective;
pub use semigroup::Semigroup;