Enum MutationKind 

pub enum MutationKind<T> {
    Replace(T),
    Append(T),
    Truncate(usize),
    Batch(Vec<Mutation<T>>),
}

The kind of mutation that occurred.

MutationKind represents the specific type of change made to a value. Different kinds enable optimizations and more precise change descriptions.

Variants

• Replace: Complete replacement of a value
• Append: Append operation for strings and vectors
• Batch: Multiple mutations combined

Example

use morphix::adapter::Json;
use morphix::{Mutation, MutationKind, Observe, observe};
use serde::Serialize;
use serde_json::json;

#[derive(Serialize, Observe)]
struct Document {
    title: String,
    content: String,
    tags: Vec<String>,
}

let mut doc = Document {
    title: "Draft".to_string(),
    content: "Hello".to_string(),
    tags: vec!["todo".to_string()],
};

let Json(mutation) = observe!(doc => {
    doc.title = "Final".to_string();      // Replace
    doc.content.push_str(" World");       // Append
    doc.tags.push("done".to_string());    // Append
}).unwrap();

// The mutation contains a Batch with three kinds
assert!(matches!(mutation.unwrap().kind, MutationKind::Batch(_)));

Variants

Replace(T)

Replace is the default mutation for DerefMut operations.

Examples

foo.a.b = 1;        // Replace at .a.b
foo.num *= 2;       // Replace at .num
foo.vec.clear();    // Replace at .vec

Note

If an operation can be represented as Append, it will be preferred over Replace for efficiency.

Append(T)

Available on crate feature append only.

Append represents adding data to the end of a string or vector. This is more efficient than Replace because only the appended portion needs to be serialized and transmitted.

Examples

foo.a.b += "text";          // Append to .a.b
foo.a.b.push_str("text");   // Append to .a.b
foo.vec.push(1);            // Append to .vec
foo.vec.extend(iter);       // Append to .vec

Truncate(usize)

Available on crate feature truncate only.

Truncate represents removing elements from the end of a string or vector. This is more efficient than Replace because only the truncation length needs to be serialized and transmitted.

Examples

let mut foo = Foo {
    a: A { b: "Hello, World!".to_string() },
    vec: vec![1, 2, 3, 4, 5],
};
foo.a.b.truncate(5);        // Truncate 8 chars from .a.b
foo.vec.truncate(2);        // Truncate 3 elements from .vec

Batch(Vec<Mutation<T>>)

Batch combines multiple mutations that occurred during a single observation period. This is automatically created when multiple independent changes are detected.

Optimization

The batch collector (BatchTree) automatically optimizes mutations:

• Consecutive appends are merged
• Redundant changes are eliminated
• Nested paths are consolidated when possible

Trait Implementations

impl<T: Clone> Clone for MutationKind<T>

fn clone(&self) -> MutationKind<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for MutationKind<T>

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

Formats the value using the given formatter.

impl<T: PartialEq> PartialEq for MutationKind<T>

fn eq(&self, other: &MutationKind<T>) -> 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<T: Eq> Eq for MutationKind<T>

impl<T> StructuralPartialEq for MutationKind<T>