feat(deep_causality_haft): Added Foldable trait with tests.

Signed-off-by: Marvin Hansen <[email protected]>

Author: marvin-hansen

deep_causality_haft/src/extensions/hkt_option_ext.rs

@@ -3,7 +3,7 @@
  * Copyright (c) "2025" . The DeepCausality Authors and Contributors. All Rights Reserved.
  */
 
-use crate::{Applicative, Functor, HKT, Monad};
+use crate::{Applicative, Foldable, Functor, HKT, Monad};
 
 // Witness for Option
 pub struct OptionWitness;
@@ -42,6 +42,19 @@ impl Applicative<OptionWitness> for OptionWitness {
     }
 }
 
+// Implementation of Foldable for OptionWitness
+impl Foldable<OptionWitness> for OptionWitness {
+    fn fold<A, B, Func>(fa: Option<A>, init: B, mut f: Func) -> B
+    where
+        Func: FnMut(B, A) -> B,
+    {
+        match fa {
+            Some(a) => f(init, a),
+            None => init,
+        }
+    }
+}
+
 // Implementation of Monad for OptionWitness
 impl Monad<OptionWitness> for OptionWitness {
     fn bind<A, B, Func>(

deep_causality_haft/src/extensions/hkt_result_ext.rs

@@ -2,7 +2,7 @@
  * SPDX-License-Identifier: MIT
  * Copyright (c) "2025" . The DeepCausality Authors and Contributors. All Rights Reserved.
  */
-use crate::{Applicative, Functor, HKT, HKT2, Monad, Placeholder};
+use crate::{Applicative, Foldable, Functor, HKT, HKT2, Monad, Placeholder};
 
 // Witness for Result<T, E> where E is fixed
 pub struct ResultWitness<E>(Placeholder, E);
@@ -57,6 +57,22 @@ where
     }
 }
 
+// Implementation of Foldable for ResultWitness
+impl<E> Foldable<ResultWitness<E>> for ResultWitness<E>
+where
+    E: 'static,
+{
+    fn fold<A, B, Func>(fa: Result<A, E>, init: B, mut f: Func) -> B
+    where
+        Func: FnMut(B, A) -> B,
+    {
+        match fa {
+            Ok(a) => f(init, a),
+            Err(_) => init,
+        }
+    }
+}
+
 // Implementation of Monad for ResultWitness
 impl<E> Monad<ResultWitness<E>> for ResultWitness<E>
 where

deep_causality_haft/src/extensions/hkt_vec_ext.rs

@@ -3,7 +3,7 @@
  * Copyright (c) "2025" . The DeepCausality Authors and Contributors. All Rights Reserved.
  */
 
-use crate::{Applicative, Functor, HKT, Monad};
+use crate::{Applicative, Foldable, Functor, HKT, Monad};
 
 // Witness for Vec<T>
 pub struct VecWitness;
@@ -46,6 +46,17 @@ impl Applicative<VecWitness> for VecWitness {
     }
 }
 
+// Implementation of Foldable for VecWitness
+impl Foldable<VecWitness> for VecWitness {
+    fn fold<A, B, Func>(fa: <VecWitness as HKT>::Type<A>, init: B, f: Func) -> B
+    where
+        <VecWitness as HKT>::Type<A>: IntoIterator<Item = A>,
+        Func: FnMut(B, A) -> B,
+    {
+        fa.into_iter().fold(init, f)
+    }
+}
+
 // Implementation of Monad for VecWitness
 impl Monad<VecWitness> for VecWitness {
     fn bind<A, B, Func>(m_a: <VecWitness as HKT>::Type<A>, f: Func) -> <VecWitness as HKT>::Type<B>

deep_causality_haft/src/foldable.rs

@@ -0,0 +1,17 @@
+/*
+ * SPDX-License-Identifier: MIT
+ * Copyright (c) "2025" . The DeepCausality Authors and Contributors. All Rights Reserved.
+ */
+use crate::HKT;
+
+/// Foldable: Abstracts over types that can be reduced to a single summary value.
+///
+/// Generic over the HKT witness `F`.
+pub trait Foldable<F: HKT> {
+    /// Reduces the elements of the structure to a single value by applying a function.
+    ///
+    /// This is equivalent to a left-fold (foldl) operation.
+    fn fold<A, B, Func>(fa: F::Type<A>, init: B, f: Func) -> B
+    where
+        Func: FnMut(B, A) -> B;
+}

deep_causality_haft/src/lib.rs

@@ -1,6 +1,7 @@
 mod applicative;
 mod effect;
 mod extensions;
+mod foldable;
 mod functor;
 mod hkt;
 mod monad;
@@ -12,7 +13,10 @@ pub use crate::effect::{Effect3, Effect4, Effect5};
 pub use crate::extensions::hkt_option_ext::OptionWitness;
 pub use crate::extensions::hkt_result_ext::ResultWitness;
 pub use crate::extensions::hkt_vec_ext::VecWitness;
+pub use crate::foldable::Foldable;
 pub use crate::functor::Functor;
 pub use crate::hkt::{HKT, HKT2, HKT3, HKT4, HKT5, Placeholder};
 pub use crate::monad::Monad;
 pub use crate::monad_effect::{MonadEffect3, MonadEffect4, MonadEffect5};
+
+// Traversable

deep_causality_haft/tests/extensions/hkt_option_ext_tests.rs

@@ -3,7 +3,7 @@
  * Copyright (c) "2025" . The DeepCausality Authors and Contributors. All Rights Reserved.
  */
 
-use deep_causality_haft::{Applicative, Functor, HKT, Monad, OptionWitness};
+use deep_causality_haft::{Applicative, Foldable, Functor, HKT, Monad, OptionWitness};
 
 // --- Applicative Tests ---
 
@@ -37,6 +37,32 @@ fn test_applicative_option_apply_none_val() {
     assert_eq!(result, None);
 }
 
+// --- Foldable Tests ---
+
+#[test]
+fn test_foldable_option_some() {
+    let opt = Some(5);
+    let result = OptionWitness::fold(opt, 0, |acc, x| acc + x);
+    assert_eq!(result, 5);
+}
+
+#[test]
+fn test_foldable_option_none() {
+    let opt: Option<i32> = None;
+    let result = OptionWitness::fold(opt, 0, |acc, x| acc + x);
+    assert_eq!(result, 0);
+}
+
+#[test]
+fn test_foldable_option_string_concat() {
+    let opt = Some("hello".to_string());
+    let result = OptionWitness::fold(opt, String::new(), |mut acc, x| {
+        acc.push_str(&x);
+        acc
+    });
+    assert_eq!(result, "hello");
+}
+
 // --- HKT Tests ---
 
 #[test]

deep_causality_haft/tests/extensions/hkt_result_ext_tests.rs

@@ -2,7 +2,7 @@
  * SPDX-License-Identifier: MIT
  * Copyright (c) "2025" . The DeepCausality Authors and Contributors. All Rights Reserved.
  */
-use deep_causality_haft::{Applicative, Functor, HKT, HKT2, Monad, ResultWitness};
+use deep_causality_haft::{Applicative, Foldable, Functor, HKT, HKT2, Monad, ResultWitness};
 
 // --- Applicative Tests ---
 
@@ -36,6 +36,32 @@ fn test_applicative_result_apply_err_val() {
     assert_eq!(result, Err("Value Error".to_string()));
 }
 
+// --- Foldable Tests ---
+
+#[test]
+fn test_foldable_result_ok() {
+    let res: Result<i32, String> = Ok(5);
+    let result = ResultWitness::fold(res, 0, |acc, x| acc + x);
+    assert_eq!(result, 5);
+}
+
+#[test]
+fn test_foldable_result_err() {
+    let res: Result<i32, String> = Err("error".to_string());
+    let result = ResultWitness::fold(res, 0, |acc, x| acc + x);
+    assert_eq!(result, 0);
+}
+
+#[test]
+fn test_foldable_result_string_concat() {
+    let res: Result<String, String> = Ok("world".to_string());
+    let result = ResultWitness::fold(res, String::new(), |mut acc, x| {
+        acc.push_str(&x);
+        acc
+    });
+    assert_eq!(result, "world");
+}
+
 // --- HKT Tests ---
 
 #[test]

deep_causality_haft/tests/extensions/hkt_vec_ext_tests.rs

@@ -3,7 +3,7 @@
  * Copyright (c) "2025" . The DeepCausality Authors and Contributors. All Rights Reserved.
  */
 
-use deep_causality_haft::{Applicative, Functor, HKT, Monad, VecWitness};
+use deep_causality_haft::{Applicative, Foldable, Functor, HKT, Monad, VecWitness};
 
 // --- Applicative Tests ---
 
@@ -38,6 +38,32 @@ fn test_applicative_vec_apply_empty_val() {
     assert_eq!(result, Vec::<i32>::new());
 }
 
+// --- Foldable Tests ---
+
+#[test]
+fn test_foldable_vec_non_empty() {
+    let vec = vec![1, 2, 3];
+    let result = VecWitness::fold(vec, 0, |acc, x| acc + x);
+    assert_eq!(result, 6);
+}
+
+#[test]
+fn test_foldable_vec_empty() {
+    let vec: Vec<i32> = Vec::new();
+    let result = VecWitness::fold(vec, 0, |acc, x| acc + x);
+    assert_eq!(result, 0);
+}
+
+#[test]
+fn test_foldable_vec_string_concat() {
+    let vec = vec!["hello".to_string(), " ".to_string(), "world".to_string()];
+    let result = VecWitness::fold(vec, String::new(), |mut acc, x| {
+        acc.push_str(&x);
+        acc
+    });
+    assert_eq!(result, "hello world");
+}
+
 // --- HKT Tests ---
 
 #[test]

deep_causality_haft/tests/foldable_tests.rs

@@ -0,0 +1,84 @@
+/*
+ * SPDX-License-Identifier: MIT
+ * Copyright (c) "2025" . The DeepCausality Authors and Contributors. All Rights Reserved.
+ */
+
+use deep_causality_haft::{Foldable, OptionWitness, ResultWitness, VecWitness};
+
+// --- OptionWitness Foldable Tests ---
+
+#[test]
+fn test_foldable_option_some() {
+    let opt = Some(5);
+    let result = OptionWitness::fold(opt, 0, |acc, x| acc + x);
+    assert_eq!(result, 5);
+}
+
+#[test]
+fn test_foldable_option_none() {
+    let opt: Option<i32> = None;
+    let result = OptionWitness::fold(opt, 0, |acc, x| acc + x);
+    assert_eq!(result, 0);
+}
+
+#[test]
+fn test_foldable_option_string_concat() {
+    let opt = Some("hello".to_string());
+    let result = OptionWitness::fold(opt, String::new(), |mut acc, x| {
+        acc.push_str(&x);
+        acc
+    });
+    assert_eq!(result, "hello");
+}
+
+// --- ResultWitness Foldable Tests ---
+
+#[test]
+fn test_foldable_result_ok() {
+    let res: Result<i32, String> = Ok(5);
+    let result = ResultWitness::fold(res, 0, |acc, x| acc + x);
+    assert_eq!(result, 5);
+}
+
+#[test]
+fn test_foldable_result_err() {
+    let res: Result<i32, String> = Err("error".to_string());
+    let result = ResultWitness::fold(res, 0, |acc, x| acc + x);
+    assert_eq!(result, 0);
+}
+
+#[test]
+fn test_foldable_result_string_concat() {
+    let res: Result<String, String> = Ok("world".to_string());
+    let result = ResultWitness::fold(res, String::new(), |mut acc, x| {
+        acc.push_str(&x);
+        acc
+    });
+    assert_eq!(result, "world");
+}
+
+// --- VecWitness Foldable Tests ---
+
+#[test]
+fn test_foldable_vec_non_empty() {
+    let vec = vec![1, 2, 3];
+    let result = VecWitness::fold(vec, 0, |acc, x| acc + x);
+    assert_eq!(result, 6);
+}
+
+#[test]
+fn test_foldable_vec_empty() {
+    let vec: Vec<i32> = Vec::new();
+    let result = VecWitness::fold(vec, 0, |acc, x| acc + x);
+    assert_eq!(result, 0);
+}
+
+#[test]
+fn test_foldable_vec_string_concat() {
+    let vec = vec!["hello".to_string(), " ".to_string(), "world".to_string()];
+    let result = VecWitness::fold(vec, String::new(), |mut acc, x| {
+        acc.push_str(&x);
+        acc
+    });
+    assert_eq!(result, "hello world");
+}

deep_causality_haft/tests/mod.rs

@@ -4,7 +4,8 @@
  */
 
 mod extensions;
-
+#[cfg(test)]
+mod foldable_tests;
 #[cfg(test)]
 mod hkt_tests;
 #[cfg(test)]