Function diff_changes

pub fn diff_changes<'a, T: HasChanges>(
    old: &'a T,
    new: &'a T,
) -> Vec<T::Change<'a>>

Convenience helper.

Examples found in repository

examples/vec-changes.rs (line 35)

fn main() {
    // 1. Tail-removal of a duplicate
    let old = Bag {
        items: vec!['A', 'A', 'A', 'A'],
    };
    let new = Bag {
        items: vec!['A', 'A', 'A'],
    };
    dump("[A, A, A, A] -> [A, A, A]", &diff_changes(&old, &new));

    // 2. Remove first element ⇒ everything shifts left
    let old = Bag {
        items: vec!['A', 'B', 'C'],
    };
    let new = Bag {
        items: vec!['B', 'C'],
    };
    dump("[A, B, C] -> [B, C]", &diff_changes(&old, &new));

    // 3. Mixed removal + moves with duplicates
    let old = Bag {
        items: vec!['A', 'B', 'A', 'A'],
    };
    let new = Bag {
        items: vec!['B', 'A', 'A'],
    };
    dump("[A, B, A, A] -> [B, A, A]", &diff_changes(&old, &new));

    // 4. Pure insertions (one value appears for the first time, then again)
    let old = Bag {
        items: vec!['X', 'Y'],
    };
    let new = Bag {
        items: vec!['X', 'A', 'Y', 'A'],
    };
    dump("[X,Y] -> [X,A, Y,A]", &diff_changes(&old, &new));
}

examples/changes.rs (line 37)

fn main() {
    let old = User {
        age: 30,
        address: Address {
            street: "1 Main".into(),
            city: "Paris".into(),
            residents: vec!["Alice".into(), "Bob".into()],
        },
    };

    let mut new = old.clone();
    new.age = 31; // scalar
    new.address.city = "Berlin".into(); // nested scalar
    new.address.residents.retain(|n| n != "Bob"); // remove one
    new.address.residents.push("Carol".into()); // add one

    let changes = diff_changes(&old, &new);

    for ch in &changes {
        #[allow(clippy::deprecated_cfg_attr)]
        #[cfg_attr(rustfmt, rustfmt_skip)]
        match ch {
            UserChange::age(age) => println!("age -> {age}"),
            UserChange::address(AddressChange::self_(address)) => println!("address -> {address:?}"),
            UserChange::address(AddressChange::city(val)) => println!("city -> {val}"),
            UserChange::address(AddressChange::residents(Changed::Added(name))) => println!("resident + -> {name}"),
            UserChange::address(AddressChange::residents(Changed::Removed(name))) => println!("resident - -> {name}"),
            _ => {}
        }
    }

    for ch in &changes {
        changed!(ch;
            User.age(age)                      => { println!("age -> {age}"); };
            User.address@(snapshot)            => { println!("address -> {snapshot:?}"); };
            User.address.city(v)               => { println!("city -> {v}"); };
            User.address.residents(Added(v))   => { println!("+res -> {v}"); };
            User.address.residents(Removed(v)) => { println!("-res -> {v}"); };
        );
    }

    println!("\nCHANGES: {changes:?}");
}

examples/complex.rs (line 149)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    /* baseline */
    let old = Company {
        name: "Acme Inc.".into(),
        staff: vec![
            Account {
                id: 1,
                username: "alice".into(),
                password: "secret".into(),
                roles: HashSet::from(["admin".into()]),
                preferences: HashMap::from([("theme".into(), "dark".into())]),
                address: Address {
                    street: "1 Main".into(),
                    city: "Paris".into(),
                },
            },
            Account {
                id: 2,
                username: "bob".into(),
                password: "hunter2".into(),
                roles: HashSet::from(["user".into()]),
                preferences: HashMap::new(),
                address: Address {
                    street: "99 Broadway".into(),
                    city: "London".into(),
                },
            },
        ],
    };

    /* edited version  */
    let mut new = old.clone();
    new.name = "Acme Corp.".into();
    new.staff[0].address.city = "Berlin".into();
    new.staff[0].roles.insert("devops".into());
    new.staff[1].roles.remove("user");
    new.staff[0]
        .preferences
        .insert("notifications".into(), "email".into());

    /* insert + move */
    let charlie = Account {
        id: 3,
        username: "charlie".into(),
        password: "pwd".into(),
        roles: HashSet::from(["user".into()]),
        preferences: HashMap::new(),
        address: Address {
            street: "5 High".into(),
            city: "Madrid".into(),
        },
    };
    new.staff.insert(0, charlie); // AddedAt
    new.staff.swap(1, 2); // Moved

    println!("Company diff");
    let diff = diff_changes(&old, &new);
    dump_company(&diff);

    println!("\n Alice diff");
    let old_alice = old.staff.iter().find(|a| a.id == 1).unwrap();
    let new_alice = new.staff.iter().find(|a| a.id == 1).unwrap();
    let alice_diff = diff_changes(old_alice, new_alice);
    dump_account(&alice_diff);

    Ok(())
}