Function diff_including 

pub fn diff_including<T: Serialize>(
    old: &T,
    new: &T,
    including: &[&str],
) -> Result<Value, Error>

Computes a JSON diff, forcing specific fields to be included even if unchanged.

This is useful when you need to provide context (like an ID) in the patch, regardless of whether that field has changed.

Example

use serde_json::json;

#[derive(serde::Serialize)]
struct User { id: u32, name: String }

let old = User { id: 1, name: "old".to_string() };
let new = User { id: 1, name: "new".to_string() };

// "id" is included even though it didn't change
let patch = serde_patch::diff_including(&old, &new, &["id"]).unwrap();
assert_eq!(patch, json!({ "id": 1, "name": "new" }));

Examples found in repository

examples/full.rs (line 46)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let old = User {
        id: 1001,
        username: "alice".to_string(),
        age: 30,
        active: true,
        profile: Some(Profile {
            bio: "Software engineer".to_string(),
            avatar_url: Some("https://example.com/alice-old.jpg".to_string()),
        }),
    };

    let new = User {
        id: 1001,
        username: "alice".to_string(),
        age: 31,
        active: false,
        profile: Some(Profile {
            bio: "Senior software engineer".to_string(),
            avatar_url: None,
        }),
    };

    // Basic diff – only changed fields
    let basic_patch = serde_json::to_string(&serde_patch::diff(&old, &new)?)?;
    println!("Basic patch (no forced fields):\n{}", basic_patch);

    // Diff with forced field – includes "id" even though unchanged
    let forced_patch = serde_json::to_string(&serde_patch::diff_including(&old, &new, &["id"])?)?;
    println!("\nPatch with forced \"id\":\n{}", forced_patch);

    // Apply immutably
    let updated = serde_patch::apply(old.clone(), &basic_patch)?;
    println!("\nImmutable apply result:\n{:#?}", updated);

    // Apply mutably
    let mut current = old;
    serde_patch::apply_mut(&mut current, &forced_patch)?;
    println!("\nMutable apply result:\n{:#?}", current);

    assert_eq!(updated, new);
    assert_eq!(current, new);

    Ok(())
}