Struct Mutation 

pub struct Mutation<A: Adapter> {
    pub path: Path<true>,
    pub kind: MutationKind<A>,
}

A mutation representing a change to a value at a specific path.

Mutation captures both the location where a change occurred (via path) and the kind of change that was made (via operation). Mutations can be applied to values to reproduce the changes they represent.

Path Representation

The path is stored in reverse order for efficiency during collection. For example, a change at foo.bar.baz would have path = ["baz", "bar", "foo"].

Example

use morphix::{JsonAdapter, Mutation, MutationKind};
use serde_json::json;

// A mutation that replaces the value at path "user.name"
let mutation = Mutation::<JsonAdapter> {
    path: vec!["user".into(), "name".into()].into(),
    kind: MutationKind::Replace(json!("Alice")),
};

// Apply the mutation to a JSON value
let mut data = json!({"user": {"name": "Bob", "age": 30}});
mutation.apply(&mut data).unwrap();
assert_eq!(data, json!({"user": {"name": "Alice", "age": 30}}));

Fields

path: Path<true>

The path to the mutated value, stored in reverse order.

An empty vec indicates a mutation at the root level.

kind: MutationKind<A>

The kind of mutation that occurred.

Implementations

impl<A: Adapter> Mutation<A>

pub fn apply(self, value: &mut A::Value) -> Result<(), MutationError>

Applies this mutation to a value.

Errors

• Returns IndexError if the path doesn’t exist in the value.
• Returns OperationError if the mutation cannot be performed.

Example

use morphix::{Mutation, MutationKind, JsonAdapter};
use serde_json::json;

let mut value = json!({"count": 0});

Mutation::<JsonAdapter> {
    path: vec!["count".into()].into(),
    kind: MutationKind::Replace(json!(42)),
}
.apply(&mut value)
.unwrap();

assert_eq!(value, json!({"count": 42}));

pub fn coalesce(mutations: Vec<Mutation<A>>) -> Option<Mutation<A>>

Coalesce many mutations as a single mutation.

• Returns None if no mutations exist.
• Returns a single mutation if only one mutation exists.
• Returns a Batch mutation if multiple mutations exist.

Trait Implementations

impl<A: Adapter> Clone for Mutation<A>

where A::Value: Clone,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<A: Adapter> Debug for Mutation<A>

where A::Value: Debug,

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

Formats the value using the given formatter.

impl<A: Adapter> PartialEq for Mutation<A>

where A::Value: PartialEq,

fn eq(&self, other: &Self) -> 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<A: Adapter> Eq for Mutation<A>

where A::Value: Eq,