Struct ReflectedChange 

pub struct ReflectedChange<'a> {
    pub path: FieldPath,
    pub change_type: ChangeType,
    pub old: Option<&'a dyn PartialReflect>,
    pub new: Option<&'a dyn PartialReflect>,
}

A detected change with references to the actual field values.

This struct is returned by diff_reflect and contains:

• The path to the changed field
• The type of change (Modified, Added, Removed, etc.)
• Optional references to the old and new values

Accessing Values

The old and new fields are Option<&dyn PartialReflect>. You can:

• Check if they’re Some or None (e.g., None for old if the field was added)
• Downcast to concrete types using try_downcast_ref::<T>()

Example

use serde::Serialize;
use bevy_reflect::Reflect;
use hashmark::diff_reflect;

#[derive(Serialize, Reflect)]
struct Data { value: u32 }

let old = Data { value: 1 };
let new = Data { value: 2 };

let changes = diff_reflect(&old, &new).unwrap();
if let Some(change) = changes.first() {
    if let Some(old_val) = &change.old {
        if let Some(n) = old_val.try_downcast_ref::<u32>() {
            println!("Old value: {}", n);
        }
    }
}

Fields

path: FieldPath

The path to the changed field (e.g., “address.city”).

change_type: ChangeType

The type of change detected.

old: Option<&'a dyn PartialReflect>

Reference to the old value, if available.

This will be None for:

• Added fields/elements
• Fields that couldn’t be resolved via reflection

new: Option<&'a dyn PartialReflect>

Reference to the new value, if available.

This will be None for:

• Removed fields/elements
• Fields that couldn’t be resolved via reflection

Trait Implementations

impl<'a> Debug for ReflectedChange<'a>

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

Formats the value using the given formatter.