Trying a new approach for HKT traits and extensions for Uncertain type

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

Author: marvin-hansen

Cargo.lock

@@ -46,6 +46,10 @@ all-features = true
 path = "../deep_causality_haft"
 version = "0.2"
 
+[dependencies.deep_causality_num]
+path = "../deep_causality_num"
+version = "0.1"
+
 [dev-dependencies]
 rusty-fork = "0.3.1"
 criterion = { version = "0.7.0", features = ["html_reports"] }

deep_causality_uncertain/Cargo.toml

@@ -0,0 +1,13 @@
+/*
+ * SPDX-License-Identifier: MIT
+ * Copyright (c) "2025" . The DeepCausality Authors and Contributors. All Rights Reserved.
+ */
+
+use crate::Uncertain;
+use deep_causality_haft::HKT;
+
+pub struct MaybeUncertainWitness {}
+
+impl HKT for MaybeUncertainWitness {
+    type Type<T> = Uncertain<T>;
+}

deep_causality_uncertain/src/extensions/hkt_maybe_uncertain/mod.rs

@@ -0,0 +1,63 @@
+/*
+ * SPDX-License-Identifier: MIT
+ * Copyright (c) "2025" . The DeepCausality Authors and Contributors. All Rights Reserved.
+ */
+
+use crate::Uncertain;
+use crate::{ProbabilisticType, UncertainApplicative, UncertainFunctor, UncertainMonad};
+use deep_causality_haft::HKT;
+
+pub struct UncertainWitness {}
+
+impl HKT for UncertainWitness {
+    type Type<T> = Uncertain<T>;
+}
+
+impl UncertainApplicative<UncertainWitness> for UncertainWitness {
+    fn pure<T>(value: T) -> <UncertainWitness as HKT>::Type<T>
+    where
+        T: ProbabilisticType,
+    {
+        unimplemented!()
+    }
+
+    fn apply<A, B, Func>(
+        f_ab: <UncertainWitness as HKT>::Type<Func>,
+        f_a: <UncertainWitness as HKT>::Type<A>,
+    ) -> <UncertainWitness as HKT>::Type<B>
+    where
+        Func: FnMut(A) -> B,
+        A: ProbabilisticType,
+        B: ProbabilisticType,
+    {
+        unimplemented!()
+    }
+}
+
+impl UncertainFunctor<UncertainWitness> for UncertainWitness {
+    fn fmap<A, B, Func>(
+        m_a: <UncertainWitness as HKT>::Type<A>,
+        f: Func,
+    ) -> <UncertainWitness as HKT>::Type<B>
+    where
+        Func: FnMut(A) -> B,
+        A: ProbabilisticType,
+        B: ProbabilisticType,
+    {
+        unimplemented!()
+    }
+}
+
+impl UncertainMonad<UncertainWitness> for UncertainWitness {
+    fn bind<A, B, Func>(
+        m_a: <UncertainWitness as HKT>::Type<A>,
+        f: Func,
+    ) -> <UncertainWitness as HKT>::Type<B>
+    where
+        Func: FnMut(A) -> <UncertainWitness as HKT>::Type<B>,
+        A: ProbabilisticType,
+        B: ProbabilisticType,
+    {
+        unimplemented!()
+    }
+}

deep_causality_uncertain/src/extensions/hkt_uncertain/mod.rs

@@ -0,0 +1,7 @@
+/*
+ * SPDX-License-Identifier: MIT
+ * Copyright (c) "2025" . The DeepCausality Authors and Contributors. All Rights Reserved.
+ */
+pub(crate) mod hkt_maybe_uncertain;
+pub(crate) mod hkt_uncertain;
+pub(crate) mod probabilistic_type;

deep_causality_uncertain/src/extensions/mod.rs

@@ -3,15 +3,16 @@
  * Copyright (c) "2025" . The DeepCausality Authors and Contributors. All Rights Reserved.
  */
 
-use crate::ProbabilisticType;
-use crate::errors::UncertainError;
-use crate::types::cache::SampledValue;
+use crate::{FromSampledValue, IntoSampledValue, ProbabilisticType};
+use crate::{SampledValue, UncertainError};
 
-impl ProbabilisticType for bool {
-    fn to_sampled_value(&self) -> SampledValue {
+impl IntoSampledValue for bool {
+    fn into_sampled_value(&self) -> SampledValue {
         SampledValue::Bool(*self)
     }
+}
 
+impl FromSampledValue for bool {
     fn from_sampled_value(value: SampledValue) -> Result<Self, UncertainError> {
         match value {
             SampledValue::Bool(b) => Ok(b),
@@ -20,7 +21,9 @@ impl ProbabilisticType for bool {
             )),
         }
     }
+}
 
+impl ProbabilisticType for bool {
     fn default_value() -> Self {
         false
     }

deep_causality_uncertain/src/traits/probabilistic_type/bool_probabilistic_type.rs renamed to deep_causality_uncertain/src/extensions/probabilistic_type/bool_probabilistic_type.rs

@@ -3,15 +3,17 @@
  * Copyright (c) "2025" . The DeepCausality Authors and Contributors. All Rights Reserved.
  */
 
-use crate::ProbabilisticType;
-use crate::errors::UncertainError;
-use crate::types::cache::SampledValue;
+use crate::{FromSampledValue, IntoSampledValue, ProbabilisticType};
+use crate::{SampledValue, UncertainError};
+use deep_causality_num::ToPrimitive;
 
-impl ProbabilisticType for f64 {
-    fn to_sampled_value(&self) -> SampledValue {
-        SampledValue::Float(*self)
+impl IntoSampledValue for f64 {
+    fn into_sampled_value(&self) -> SampledValue {
+        SampledValue::Float(self.to_f64().unwrap_or(f64::NAN))
     }
+}
 
+impl FromSampledValue for f64 {
     fn from_sampled_value(value: SampledValue) -> Result<Self, UncertainError> {
         match value {
             SampledValue::Float(f) => Ok(f),
@@ -20,8 +22,10 @@ impl ProbabilisticType for f64 {
             )),
         }
     }
+}
 
+impl ProbabilisticType for f64 {
     fn default_value() -> Self {
-        0.0
+        f64::default()
     }
 }

deep_causality_uncertain/src/traits/probabilistic_type/f64_probabilistic_type.rs renamed to deep_causality_uncertain/src/extensions/probabilistic_type/f64_probabilistic_type.rs

@@ -0,0 +1,7 @@
+/*
+ * SPDX-License-Identifier: MIT
+ * Copyright (c) "2025" . The DeepCausality Authors and Contributors. All Rights Reserved.
+ */
+
+mod bool_probabilistic_type;
+mod f64_probabilistic_type;

deep_causality_uncertain/src/extensions/probabilistic_type/mod.rs

@@ -8,6 +8,7 @@
 mod algos;
 mod alias;
 mod errors;
+mod extensions;
 mod traits;
 mod types;
 pub mod utils_tests;
@@ -18,9 +19,14 @@ pub use crate::algos::hypothesis::sprt_eval;
 pub use crate::alias::{MaybeUncertainBool, MaybeUncertainF64, UncertainBool, UncertainF64};
 // Errors
 pub use crate::errors::UncertainError;
+// Extensions
+pub use crate::extensions::hkt_maybe_uncertain::MaybeUncertainWitness;
+pub use crate::extensions::hkt_uncertain::UncertainWitness;
 // Traits
-pub use crate::traits::hkt::{UncertainApplicative, UncertainFunctor, UncertainMonad};
-pub use crate::traits::probabilistic_type::ProbabilisticType;
+pub use crate::traits::hkt::uncertain_applicative::UncertainApplicative;
+pub use crate::traits::hkt::uncertain_functor::UncertainFunctor;
+pub use crate::traits::hkt::uncertain_monad::UncertainMonad;
+pub use crate::traits::probabilistic::{FromSampledValue, IntoSampledValue, ProbabilisticType};
 pub use crate::traits::sampler::Sampler;
 // Types
 pub use crate::types::cache::{GlobalSampleCache, SampledValue, with_global_cache};

deep_causality_uncertain/src/lib.rs

@@ -3,33 +3,6 @@
  * Copyright (c) "2025" . The DeepCausality Authors and Contributors. All Rights Reserved.
  */
 
-use crate::ProbabilisticType;
-use deep_causality_haft::HKT;
-
-pub trait UncertainFunctor<F: HKT> {
-    fn fmap<A, B, Func>(m_a: F::Type<A>, f: Func) -> F::Type<B>
-    where
-        Func: FnMut(A) -> B,
-        A: ProbabilisticType,
-        B: ProbabilisticType;
-}
-
-pub trait UncertainApplicative<F: HKT> {
-    fn pure<T>(value: T) -> F::Type<T>
-    where
-        T: ProbabilisticType;
-
-    fn apply<A, B, Func>(f_ab: F::Type<Func>, f_a: F::Type<A>) -> F::Type<B>
-    where
-        Func: FnMut(A) -> B,
-        A: ProbabilisticType,
-        B: ProbabilisticType;
-}
-
-pub trait UncertainMonad<F: HKT> {
-    fn bind<A, B, Func>(m_a: F::Type<A>, f: Func) -> F::Type<B>
-    where
-        Func: FnMut(A) -> F::Type<B>,
-        A: ProbabilisticType,
-        B: ProbabilisticType;
-}
+pub(crate) mod uncertain_applicative;
+pub(crate) mod uncertain_functor;
+pub(crate) mod uncertain_monad;