Enum Modification 

pub enum Modification {
    Delta,
    Replace,
    Delete,
}

A description of how a value should be updated.

The enum is intentionally tiny – only the three actions that matter in our state‑diff engine. Each variant is documented with a short, practical example so you know exactly when you’d pick it.

The enum is Copy, so you can freely pass it around without ownership worries. The From<&str> implementation below lets you read the operation name from configuration files or CLI flags:

Variants

Delta

The modification will be a delta, i.e. an increment.

For numeric values this is equivalent to adding the new value to the existing one. For collections it usually means “append”.

Replace

The modification will replace the existing value.

This is a hard overwrite: the old value is dropped entirely and the new one is written in its place.

Delete

The modification will reset the underlying value.

For plain types this is typically a default/zero value. For Option<T> it sets the field to None. It can also be interpreted as “delete the field entirely”.

Trait Implementations

impl Clone for Modification

fn clone(&self) -> Modification

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Modification

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

Formats the value using the given formatter.

impl From<bool> for Modification

fn from(value: bool) -> Self

Converts to this type from the input type.

impl FromStr for Modification

type Err = EpochError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl Hash for Modification

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Modification

fn eq(&self, other: &Modification) -> 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 Copy for Modification

impl Eq for Modification

impl StructuralPartialEq for Modification