karpal_std/
lib.rs

1// Standard prelude for the Karpal ecosystem.
2//
3// Re-exports the most commonly used types and traits from
4// `karpal-core`, `karpal-profunctor`, and `karpal-optics`.
5
6/// Prelude module — `use karpal_std::prelude::*` to import everything.
7pub mod prelude {
8    // HKT encoding
9    pub use karpal_core::hkt::{
10        EnvF, HKT, HKT2, IdentityF, NonEmptyVec, NonEmptyVecF, OptionF, ReaderF, ResultBF, ResultF,
11        StoreF, TracedF, TupleF, VecF,
12    };
13
14    // Functor hierarchy
15    pub use karpal_core::{
16        Alt, Alternative, Applicative, Apply, Chain, Functor, FunctorFilter, Monad,
17    };
18
19    // Foldable / Traversable
20    pub use karpal_core::{Foldable, Traversable};
21
22    // Comonad hierarchy
23    pub use karpal_core::{Comonad, ComonadEnv, ComonadStore, ComonadTraced, Extend};
24
25    // Bifunctor, Selective, NaturalTransformation, DinaturalTransformation
26    pub use karpal_core::{Bifunctor, DinaturalTransformation, NaturalTransformation, Selective};
27
28    // Invariant
29    pub use karpal_core::Invariant;
30
31    // Contravariant hierarchy
32    pub use karpal_core::{Conclude, Contravariant, Decide, Divide, Divisible, PredicateF};
33
34    // Plus
35    pub use karpal_core::Plus;
36
37    // Algebraic typeclasses
38    pub use karpal_core::{Monoid, Semigroup};
39
40    // Newtype wrappers
41    pub use karpal_core::{First, Last, Max, Min, Product, Sum};
42
43    // Adjunctions & advanced category theory
44    pub use karpal_core::{
45        Adjunction, Coend, ComposeF, ContAdj, ContF, ContravariantAdjunction, CurryAdj, End,
46        IdentityAdj, ProfunctorAdjunction, ProfunctorFunctor, ProfunctorIdentityAdj,
47        ProfunctorIdentityF,
48    };
49
50    // Abstract algebra
51    pub use karpal_algebra::{
52        AbelianGroup, BoundedLattice, Field, Group, Lattice, Module, Ring, Semiring, VectorSpace,
53    };
54
55    // Profunctor
56    pub use karpal_profunctor::{Choice, FnP, ForgetF, Profunctor, Strong, TaggedF, Traversing};
57
58    // Optics
59    pub use karpal_optics::fold::{ComposedFold, Fold};
60    pub use karpal_optics::getter::{ComposedGetter, Getter};
61    pub use karpal_optics::iso::{Iso, SimpleIso};
62    pub use karpal_optics::lens::{ComposedLens, Lens, SimpleLens};
63    pub use karpal_optics::optic::Optic;
64    pub use karpal_optics::review::Review;
65    pub use karpal_optics::setter::{Setter, SimpleSetter};
66    pub use karpal_optics::traversal::{ComposedTraversal, SimpleTraversal, Traversal};
67    pub use karpal_optics::{Prism, SimplePrism};
68
69    // Arrow hierarchy
70    pub use karpal_arrow::{
71        Arrow, ArrowApply, ArrowChoice, ArrowLoop, ArrowPlus, ArrowZero, Category, CokleisliF, FnA,
72        KleisliF, Semigroupoid,
73    };
74
75    // Arrow macros
76    pub use karpal_arrow::{impl_cokleisli, impl_cokleisli_env};
77
78    // Free constructions
79    pub use karpal_free::{
80        Codensity, CodensityF, Cofree, CofreeF, Coyoneda, CoyonedaF, Day, DayF, Density, DensityF,
81        Free, FreeAlt, FreeAltF, FreeAp, FreeApF, FreeF, Freer, FreerF, Lan, LanF, Ran, RanMapped,
82        Yoneda, YonedaF,
83    };
84
85    // Recursion schemes
86    pub use karpal_recursion::{
87        Either, Fix, FixF, Mu, Nu, ana, apo, cata, chrono, futu, histo, hylo, para, zygo,
88    };
89
90    // Effect system / Monad transformers
91    pub use karpal_effect::{
92        ApplicativeSt, ChainSt, ExceptTF, FunctorSt, MonadTrans, ReaderTF, StateTF, WriterTF,
93    };
94
95    // Macros
96    pub use karpal_core::{ado_, do_};
97}
98
99// Crate re-exports for qualified access
100pub use karpal_algebra;
101pub use karpal_arrow;
102pub use karpal_core;
103pub use karpal_effect;
104pub use karpal_free;
105pub use karpal_optics;
106pub use karpal_profunctor;
107pub use karpal_recursion;
108
109// Macro re-exports
110pub use karpal_core::ado_;
111pub use karpal_core::do_;
112
113#[cfg(test)]
114mod tests {
115    use super::prelude::*;
116
117    #[test]
118    fn prelude_hkt_accessible() {
119        let _: <OptionF as HKT>::Of<i32> = Some(42);
120        let _: <VecF as HKT>::Of<i32> = vec![1, 2, 3];
121        let _: <ResultF<String> as HKT>::Of<i32> = Ok(42);
122    }
123
124    #[test]
125    fn prelude_functor_accessible() {
126        let result = <OptionF as Functor>::fmap(Some(1), |x| x + 1);
127        assert_eq!(result, Some(2));
128    }
129
130    #[test]
131    fn prelude_lens_accessible() {
132        let lens: SimpleLens<(i32, i32), i32> = Lens::new(|p: &(i32, i32)| p.0, |p, x| (x, p.1));
133        assert_eq!(lens.get(&(1, 2)), 1);
134    }
135
136    #[test]
137    fn prelude_prism_accessible() {
138        let prism: SimplePrism<Option<i32>, i32> = Prism::new(
139            |s| match s {
140                Some(v) => Ok(v),
141                None => Err(None),
142            },
143            Some,
144        );
145        assert_eq!(prism.preview(&Some(42)), Some(42));
146        assert_eq!(prism.preview(&None), None);
147    }
148
149    #[test]
150    fn prelude_profunctor_accessible() {
151        let f: <FnP as HKT2>::P<i32, i32> = Box::new(|x| x + 1);
152        assert_eq!(f(1), 2);
153    }
154
155    #[test]
156    fn prelude_arrow_accessible() {
157        let double = <FnA as Arrow>::arr(|x: i32| x * 2);
158        let inc = <FnA as Arrow>::arr(|x: i32| x + 1);
159        let composed = <FnA as Semigroupoid>::compose(inc, double);
160        assert_eq!(composed(5), 11); // (5 * 2) + 1
161    }
162}
karpal_std/lib.rs

karpal_std/
lib.rs
