Struct CausalEffectPropagationProcess 

pub struct CausalEffectPropagationProcess<Value, State, Context, Error, Log> {
    pub value: EffectValue<Value>,
    pub state: State,
    pub context: Option<Context>,
    pub error: Option<Error>,
    pub logs: Log,
}

The fundamental unit of causal computation in DeepCausality.

CausalEffectPropagationProcess encapsulates the state of a computation moving through a causal graph. It unifies value propagation, state management, context awareness, error handling, and comprehensive logging into a single, monadic structure.

Concepts

• Value: The primary data being transformed (e.g., a signal, a decision).
• State: Persistent data that evolves as the process moves through the graph (Markovian state).
• Context: Read-only configuration or environment data available to all steps.
• Error: A failure state that short-circuits further computation but preserves logs.
• Logs: An append-only history of every step, essential for auditability and explainability.

Rationale

In complex causal reasoning, it is not enough to just know the final result. We must know how that result was reached, what invalid states were encountered, and what context was active. This struct implements the Monad pattern to handle these concerns automatically, allowing users to focus on the domain logic (“Business Logic”) rather than plumbing (error checking, logging).

Fields

value: EffectValue<Value>

The current value of the computation.

state: State

The current state of the process (e.g., accumulated risk, counters).

context: Option<Context>

The optional execution context (e.g., global config, reference data).

error: Option<Error>

The current error state. If Some, new bind operations will skip execution.

logs: Log

The audit log containing the history of operations.

Implementations

impl<Value: Debug, Error: Debug, Log: Debug + Display + LogSize> CausalEffectPropagationProcess<Value, (), (), Error, Log>

pub fn explain(&self) -> String

Generates a human-readable explanation of the causal computation’s history.

This method iterates over the accumulated logs, providing a comprehensive history of the computation, including the final value and any errors.

Returns

A String containing the formatted explanation.

impl<Value, State, Context, Error, Log> CausalEffectPropagationProcess<Value, State, Context, Error, Log>

pub fn value(&self) -> &EffectValue<Value>

pub fn state(&self) -> &State

pub fn context(&self) -> &Option<Context>

pub fn error(&self) -> &Option<Error>

pub fn logs(&self) -> &Log

impl<Value, Error, Log> CausalEffectPropagationProcess<Value, (), (), Error, Log>

where Log: LogSize,

pub fn is_ok(&self) -> bool

pub fn is_err(&self) -> bool

impl<Value, State, Context, Error, Log> CausalEffectPropagationProcess<Value, State, Context, Error, Log>

where Log: LogAppend + Default, State: Clone, Context: Clone, Error: Clone,

pub fn bind<F, NewValue>( self, f: F, ) -> CausalEffectPropagationProcess<NewValue, State, Context, Error, Log>

where F: FnOnce(EffectValue<Value>, State, Option<Context>) -> CausalEffectPropagationProcess<NewValue, State, Context, Error, Log>, NewValue: Default,

Chains a stateful, context-aware computation.

This is the primary method for building Markovian process chains, as the function f receives the value, state, and context from the previous step.

impl<Value, State, Context, Error, Log> CausalEffectPropagationProcess<Value, State, Context, Error, Log>

where Log: Clone, Error: Clone,

pub fn with_state( effect: CausalEffectPropagationProcess<Value, (), (), Error, Log>, initial_state: State, initial_context: Option<Context>, ) -> Self

Lifts a stateless effect into a stateful process by providing an initial state and context.

This is the primary entry point for starting a stateful computation chain from a simple, pre-existing effect.

Arguments

• effect: The stateless PropagatingEffect (where State and Context are ()).
• initial_state: The starting state for the new process.
• initial_context: The optional starting context for the new process.

Returns

A new CausalEffectPropagationProcess ready for stateful operations.

impl<Value, State, Context> CausalEffectPropagationProcess<Value, State, Context, CausalityError, EffectLog>

where Value: Default + Clone + Debug, State: Default + Clone + Debug, Context: Clone + Debug,

pub fn from_error(err: CausalityError) -> Self

Creates a new process that explicitly contains an error. The state is set to default.

pub fn none() -> Self

Creates a new process with EffectValue::None, default state, and no error.

pub fn pure(value: Value) -> Self

Lifts a pure value into a process with a default state.

pub fn from_effect_value(effect_value: EffectValue<Value>) -> Self

Creates a new process from a given EffectValue. The state is set to default.

pub fn from_value(value: Value) -> Self

pub fn from_effect_value_with_log( value: EffectValue<Value>, logs: EffectLog, ) -> Self

Creates a new process from a given EffectValue and EffectLog. The state is set to default.

pub fn from_value_with_log(value: Value, logs: EffectLog) -> Self

impl<Value, State, Context, Log> CausalEffectPropagationProcess<Value, State, Context, CausalityError, Log>

where Log: LogAppend + Default, State: Clone, Context: Clone,

pub fn bind_or_error<F, NewValue>( self, f: F, err_msg: &str, ) -> CausalEffectPropagationProcess<NewValue, State, Context, CausalityError, Log>

where F: FnOnce(Value, State, Option<Context>) -> CausalEffectPropagationProcess<NewValue, State, Context, CausalityError, Log>, NewValue: Default,

Chains a computation while automatically unwrapping the inner EffectValue.

If the EffectValue is None, this method short-circuits with a CausalityError containing the provided err_msg. This simplifies the common pattern of: bind -> match effect_value { Some(v) => f(v), None => Error }

Trait Implementations

impl<Value: Clone, State: Clone, Context: Clone, Error: Clone, Log: Clone> Clone for CausalEffectPropagationProcess<Value, State, Context, Error, Log>

fn clone( &self, ) -> CausalEffectPropagationProcess<Value, State, Context, Error, Log>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<Value: Debug, State: Debug, Context: Debug, Error: Debug, Log: Debug> Debug for CausalEffectPropagationProcess<Value, State, Context, Error, Log>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<Value: Debug, Error: Debug, Log: Debug> Display for CausalEffectPropagationProcess<Value, (), (), Error, Log>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<Value, State, Context, Error, Log> Intervenable<Value> for CausalEffectPropagationProcess<Value, State, Context, Error, Log>

where Log: LogAppend + LogAddEntry + Default, Value: Debug,

fn intervene(self, new_value: Value) -> Self

Overrides the value within an effectful computation.

impl<Value: PartialEq, State: PartialEq, Context: PartialEq, Error: PartialEq, Log: PartialEq> PartialEq for CausalEffectPropagationProcess<Value, State, Context, Error, Log>

fn eq( &self, other: &CausalEffectPropagationProcess<Value, State, Context, Error, Log>, ) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<Value, State, Context, Error, Log> StructuralPartialEq for CausalEffectPropagationProcess<Value, State, Context, Error, Log>