Struct EffectLog 

pub struct EffectLog { /* private fields */ }

Represents an encapsulated, timestamped log of causal evaluation events.

This struct provides a high-level API for logging and ensures that all log entries are automatically timestamped. It hides the internal storage details to provide a clean and robust interface. An append-only audit log for causal operations.

EffectLog maintains a chronological record of all significant events, computations, and interventions that occur during a causal process. This is crucial for:

• Explainability: Tracing back why a certain result was reached.
• Auditability: Providing a tamper-evident record of decisions suitable for compliance.
• Debugging: Understanding the flow of complex graphs.

Implementations

impl EffectLog

pub fn new() -> EffectLog

Creates a new, empty log.

pub fn with_capacity(capacity: usize) -> EffectLog

Creates a new, empty log with a specified capacity.

pub fn eq_with_timestamps(&self, other: &EffectLog) -> bool

Strict equality that also requires entry timestamps to match.

The counterpart to the timestamp-agnostic PartialEq impl: returns true only when the two logs have the same messages and the same timestamps, in the same order. Use this when the temporal record is the subject of the comparison (e.g. auditing that two runs produced identically-timed entries); use == for ordinary value equality.

Trait Implementations

impl Clone for EffectLog

fn clone(&self) -> EffectLog

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for EffectLog

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

Formats the value using the given formatter.

impl Default for EffectLog

fn default() -> EffectLog

Returns the “default value” for a type.

impl Display for EffectLog

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

Formats the value using the given formatter.

impl Eq for EffectLog

impl From<&str> for EffectLog

Provides a clean way to create a log with a single initial entry from a string slice. e.g., let log: CausalEffectLog = "Initial message".into();

fn from(message: &str) -> EffectLog

Converts to this type from the input type.

impl From<String> for EffectLog

Provides a clean way to create a log with a single initial entry. e.g., let log: CausalEffectLog = "Initial message".to_string().into();

fn from(message: String) -> EffectLog

Converts to this type from the input type.

impl LogAddEntry for EffectLog

fn add_entry(&mut self, message: &str)

Adds a new timestamped entry to the log.

Arguments

• message - The log message string slice.

impl LogAppend for EffectLog

fn append(&mut self, other: &mut EffectLog)

Merges another log’s entries into this one. The entries from the other log are moved, and the other log will be empty after this operation.

impl LogEffect for EffectLog

impl LogSize for EffectLog

fn is_empty(&self) -> bool

Returns true if the log contains no entries.

fn len(&self) -> usize

Returns the number of entries in the log.

impl PartialEq for EffectLog

Value equality of an EffectLog is its message sequence, ignoring entry timestamps.

Each entry is timestamped with SystemTime::now() at add_entry time (or 0 under no_std). Those timestamps are wall-clock metadata: two logically identical logs built microseconds apart would otherwise never compare equal, which makes the derived structural == non-deterministic and breaks value comparison of any CausalEffectPropagationProcess carrying a non-empty log. Comparing by message content and order keeps == a meaningful, reproducible equivalence. When the timestamps themselves are the subject of comparison, use eq_with_timestamps.

fn eq(&self, other: &EffectLog) -> 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.