test(deep_causality_haft): Added and update test suite to cover all newly added types and traits.

Signed-off-by: Marvin Hansen <marvin.hansen@gmail.com>

Author: marvin-hansen

deep_causality_haft/src/algebra/mod.rs

@@ -41,8 +41,8 @@
 //! To use these traits, you typically need a type that implements the corresponding HKT witness (from `core` or `extensions`).
 //!
 //! ```rust
-//! use deep_causality_haft::algebra::functor::Functor;
-//! use deep_causality_haft::extensions::hkt_vec_ext::VecWitness;
+//! use deep_causality_haft::Functor;
+//! use deep_causality_haft::VecWitness;
 //!
 //! let v = vec![1, 2, 3];
 //! let v_mapped = VecWitness::fmap(v, |x| x * 2);

deep_causality_haft/tests/algebra/adjunction_tests.rs

@@ -0,0 +1,52 @@
+/*
+ * SPDX-License-Identifier: MIT
+ * Copyright (c) "2025" . The DeepCausality Authors and Contributors. All Rights Reserved.
+ */
+
+use deep_causality_haft::{Adjunction, HKT};
+
+// Simplified Identity for testing
+#[derive(Debug, PartialEq, Clone)]
+struct Identity<T>(T);
+struct IdentityWitness;
+impl HKT for IdentityWitness {
+    type Type<T> = Identity<T>;
+}
+
+struct IdentityAdjunction;
+
+impl Adjunction<IdentityWitness, IdentityWitness> for IdentityAdjunction {
+    fn unit<A>(a: A) -> Identity<Identity<A>> {
+        Identity(Identity(a))
+    }
+
+    fn counit<A>(fa: Identity<Identity<A>>) -> A {
+        fa.0.0
+    }
+
+    fn left_adjunct<A, B, F>(_a: A, _f: F) -> Identity<B>
+    where
+        F: Fn(Identity<A>) -> B,
+    {
+        // Simplified - not fully implemented for test
+        panic!("Not implemented for test")
+    }
+
+    fn right_adjunct<A, B, F>(_la: Identity<A>, _f: F) -> B
+    where
+        F: Fn(A) -> Identity<B>,
+    {
+        // Simplified - not fully implemented for test
+        panic!("Not implemented for test")
+    }
+}
+
+#[test]
+fn test_adjunction_identity() {
+    let val = 42;
+    let unit = IdentityAdjunction::unit(val);
+    assert_eq!(unit, Identity(Identity(42)));
+
+    let counit = IdentityAdjunction::counit(unit);
+    assert_eq!(counit, 42);
+}

deep_causality_haft/tests/algebra/applicative_tests.rs

@@ -0,0 +1,44 @@
+/*
+ * SPDX-License-Identifier: MIT
+ * Copyright (c) "2025" . The DeepCausality Authors and Contributors. All Rights Reserved.
+ */
+
+use deep_causality_haft::{Applicative, OptionWitness, ResultWitness};
+
+#[test]
+fn test_applicative_option() {
+    let pure_val = OptionWitness::pure(5);
+    assert_eq!(pure_val, Some(5));
+
+    let func = Some(|x: i32| x * 2);
+    let val = Some(10);
+    let applied = OptionWitness::apply(func, val);
+    assert_eq!(applied, Some(20));
+
+    let none_func: Option<fn(i32) -> i32> = None;
+    let applied_none_func = OptionWitness::apply(none_func, val);
+    assert_eq!(applied_none_func, None);
+
+    let none_val: Option<i32> = None;
+    let applied_none_val = OptionWitness::apply(func, none_val);
+    assert_eq!(applied_none_val, None);
+}
+
+#[test]
+fn test_applicative_result() {
+    let pure_val: Result<i32, &str> = ResultWitness::pure(5);
+    assert_eq!(pure_val, Ok(5));
+
+    let func: Result<fn(i32) -> i32, &str> = Ok(|x| x * 2);
+    let val: Result<i32, &str> = Ok(10);
+    let applied = ResultWitness::apply(func, val);
+    assert_eq!(applied, Ok(20));
+
+    let err_func: Result<fn(i32) -> i32, &str> = Err("func error");
+    let applied_err_func = ResultWitness::apply(err_func, val);
+    assert_eq!(applied_err_func, Err("func error"));
+
+    let err_val: Result<i32, &str> = Err("val error");
+    let applied_err_val = ResultWitness::apply(func, err_val);
+    assert_eq!(applied_err_val, Err("val error"));
+}

deep_causality_haft/tests/algebra/bifunctor_tests.rs

@@ -0,0 +1,25 @@
+/*
+ * SPDX-License-Identifier: MIT
+ * Copyright (c) "2025" . The DeepCausality Authors and Contributors. All Rights Reserved.
+ */
+
+use deep_causality_haft::{Bifunctor, ResultUnboundWitness};
+
+#[test]
+fn test_bifunctor_result() {
+    let ok_v: Result<i32, String> = Ok(10);
+    let bimapped_ok = ResultUnboundWitness::bimap(ok_v, |v| v * 2, |e| e);
+    assert_eq!(bimapped_ok, Ok(20));
+
+    let err_v: Result<i32, String> = Err("error".to_string());
+    let bimapped_err = ResultUnboundWitness::bimap(err_v, |v| v * 2, |e| format!("new {}", e));
+    assert_eq!(bimapped_err, Err("new error".to_string()));
+
+    let err_v2: Result<i32, String> = Err("error".to_string());
+    let first_mapped = ResultUnboundWitness::first(err_v2, |v| v + 5);
+    assert_eq!(first_mapped, Err("error".to_string()));
+
+    let ok_v2: Result<i32, String> = Ok(10);
+    let second_mapped = ResultUnboundWitness::second(ok_v2, |e| format!("mapped {}", e));
+    assert_eq!(second_mapped, Ok(10));
+}

deep_causality_haft/tests/algebra/comonad_tests.rs

@@ -0,0 +1,49 @@
+/*
+ * SPDX-License-Identifier: MIT
+ * Copyright (c) "2025" . The DeepCausality Authors and Contributors. All Rights Reserved.
+ */
+
+use deep_causality_haft::{CoMonad, Functor, HKT};
+
+// Mock Identity Comonad (since standard types don't implement Comonad easily in Rust)
+#[derive(Debug, PartialEq, Clone)]
+struct Identity<T>(T);
+
+struct IdentityWitness;
+impl HKT for IdentityWitness {
+    type Type<T> = Identity<T>;
+}
+impl Functor<IdentityWitness> for IdentityWitness {
+    fn fmap<A, B, Func>(fa: Identity<A>, mut f: Func) -> Identity<B>
+    where
+        Func: FnMut(A) -> B,
+    {
+        Identity(f(fa.0))
+    }
+}
+impl CoMonad<IdentityWitness> for IdentityWitness {
+    fn extract<A>(wa: &Identity<A>) -> A
+    where
+        A: Clone,
+    {
+        wa.0.clone()
+    }
+    fn extend<A, B, Func>(wa: &Identity<A>, mut f: Func) -> Identity<B>
+    where
+        Func: FnMut(&Identity<A>) -> B,
+    {
+        Identity(f(wa))
+    }
+}
+
+#[test]
+fn test_comonad_identity() {
+    let id = Identity(10);
+
+    // Extract
+    assert_eq!(IdentityWitness::extract(&id), 10);
+
+    // Extend
+    let extended = IdentityWitness::extend(&id, |wa| IdentityWitness::extract(wa) + 1);
+    assert_eq!(extended, Identity(11));
+}

deep_causality_haft/tests/algebra/cybernetic_loop_tests.rs

@@ -0,0 +1,53 @@
+/*
+ * SPDX-License-Identifier: MIT
+ * Copyright (c) "2025" . The DeepCausality Authors and Contributors. All Rights Reserved.
+ */
+
+use deep_causality_haft::{CyberneticLoop, HKT5Unbound};
+
+// Mock Cybernetic Loop Structure
+// (Sensor, Controller, Actuator, Feedback, Meta)
+#[derive(Debug, PartialEq, Clone)]
+struct System<S, C, A, F, M>(S, C, A, F, M);
+
+struct SystemWitness;
+impl HKT5Unbound for SystemWitness {
+    type Type<S, C, A, F, M> = System<S, C, A, F, M>;
+}
+
+impl CyberneticLoop<SystemWitness> for SystemWitness {
+    fn control_step<S, B, C, A, E, FObserve, FDecide>(
+        _agent: System<S, B, C, A, E>,
+        sensor_input: S,
+        observe_fn: FObserve,
+        decide_fn: FDecide,
+    ) -> Result<A, E>
+    where
+        FObserve: Fn(S, C) -> B,
+        FDecide: Fn(B, C) -> A,
+    {
+        // Simplified - use zero-sized type for context
+        unsafe {
+            let context: C = std::mem::zeroed();
+            let belief = observe_fn(sensor_input, context);
+            let context2: C = std::mem::zeroed();
+            let action = decide_fn(belief, context2);
+            Ok(action)
+        }
+    }
+}
+
+#[test]
+fn test_cybernetic_loop() {
+    let sys = System(1, 2, 3, 4, 100);
+
+    // Test control_step
+    let result = SystemWitness::control_step(
+        sys,
+        10,            // sensor input
+        |s, _c| s + 1, // observe: sensor -> belief
+        |b, _c| b * 2, // decide: belief -> action
+    );
+
+    assert_eq!(result, Ok(22)); // (10 + 1) * 2 = 22
+}

…p_causality_haft/tests/foldable_tests.rs …ity_haft/tests/algebra/foldable_tests.rsdeep_causality_haft/tests/foldable_tests.rs renamed to deep_causality_haft/tests/algebra/foldable_tests.rs deep_causality_haft/tests/foldable_tests.rs renamed to deep_causality_haft/tests/algebra/foldable_tests.rs

@@ -0,0 +1,35 @@
+/*
+ * SPDX-License-Identifier: MIT
+ * Copyright (c) "2025" . The DeepCausality Authors and Contributors. All Rights Reserved.
+ */
+
+use deep_causality_haft::{Functor, OptionWitness, ResultWitness, VecWitness};
+
+#[test]
+fn test_functor_option() {
+    let some_v = Some(2);
+    let mapped = OptionWitness::fmap(some_v, |x| x * 2);
+    assert_eq!(mapped, Some(4));
+
+    let none_v: Option<i32> = None;
+    let mapped_none = OptionWitness::fmap(none_v, |x| x * 2);
+    assert_eq!(mapped_none, None);
+}
+
+#[test]
+fn test_functor_result() {
+    let ok_v: Result<i32, &str> = Ok(2);
+    let mapped_ok = ResultWitness::fmap(ok_v, |x| x * 2);
+    assert_eq!(mapped_ok, Ok(4));
+
+    let err_v: Result<i32, &str> = Err("error");
+    let mapped_err = ResultWitness::fmap(err_v, |x| x * 2);
+    assert_eq!(mapped_err, Err("error"));
+}
+
+#[test]
+fn test_functor_vec() {
+    let v = vec![1, 2, 3];
+    let mapped_v = VecWitness::fmap(v, |x| x * 2);
+    assert_eq!(mapped_v, vec![2, 4, 6]);
+}

deep_causality_haft/tests/algebra/functor_tests.rs

@@ -0,0 +1,18 @@
+/*
+ * SPDX-License-Identifier: MIT
+ * Copyright (c) "2025" . The DeepCausality Authors and Contributors. All Rights Reserved.
+ */
+
+mod adjunction_tests;
+mod applicative_tests;
+mod bifunctor_tests;
+mod comonad_tests;
+mod cybernetic_loop_tests;
+mod foldable_tests;
+mod functor_tests;
+mod monad_tests;
+mod parametric_monad_tests;
+mod profunctor_tests;
+mod promonad_tests;
+mod riemann_map_tests;
+mod traversable_tests;