Support for Getting Info (Field and Value) from Diffs

[aarkue]

Hi, thanks for creating this crate, it's been a pleasure to use :)
However, for my use case I am running into some missing features of the generated Diff structs:
Retrieving the changed field name and value from a Diff (which, for example, has been deserialized using serde before).

With the debug_diff feature flag it's already possible to print such info out, but I need programmatic access it.

Example:

let diffs: Vec<<Example as StructDiff>::Diff> = first.diff(&second);
for diff in diffs {
  // Have diff.field() and diff.new_value() or something like this available here.
}

Could this be supported by this crate? Maybe also behind a feature flag?
Thanks!

[knickish]

Glad you've been liking it so far :)

A getter for the field names should be pretty straightforward, but I am a little unsure how to get you the values in a meaningful way. The <Example as StructDiff>::Diff type is an enum defined in an anonymous const to prevent the namespace from becoming polluted, but it also interferes with matching on the enum (The value can also be arbitrarily nested if structdiff(recurse) or similar is used).

Can you describe in a bit more detail how you would like to use/access the value?

[aarkue]

Sure, I think my use case is also rather simple, so there might be some shortcuts: It involves transforming (flat) diffs of a struct to another "format" (e.g., a file format which allows recording and encoding attribute changes of certain entities).

In my case the struct fields so far are all "flat" without recurse. Thus, the type of the changed value would always simply be the type of the struct field.

Currently, the alternative solution I could think of would be importing the serde-serialized diff (e.g., json) as untyped serde_json values, however this would of course cost me the convenience of type "safety".

Thanks for your help! :)

Edit: In my use case getting the changed field name would also be enough already, as I could get the new values myself via applying the diffs, so this feature would already be highly convenient on its own ;)

[knickish]

Alright, I just messed with this a bit more, and the following works:

    #[derive(Debug, PartialEq, Clone, Difference)]
    struct Example {
        field1: f64,
    }

    let first = Example {
        field1: 0.0,
    };

    let second = Example {
        field1: 3.14,
    };

    for diff in first.diff(&second) {
        type DiffType = <Example as StructDiff>::Diff;
        match diff {
            DiffType::field1(v) => {dbg!(&v);},
            _ => ()

        }
    }

Essentially you can just add an alias at the site you want to inspect the enum contents and it all should work. Does that cover your use case for accessing the value, and if so, is the field name helper still needed?

[aarkue]

Yeah, this is enough for my use case!
There are some smaller annoyances (e.g., rust-analyzer was unable to fill missing match arms automatically), but it's easy to handle.

Thanks again for your help, I was completely oblivious to the fact that the diff type is an enum you can match on.

[knickish]

Ok good, glad that works. I'll have to investigate if anything can be done to make autocomplete work for the generated types, as I ran into the same thing

[knickish]

Added an expose attribute in #35 to the derive macro to hopefully alleviate this issue