An improved flatten attribute

[nickbabcock]

I have input to deserialize into a model that may or may have been combined. For instance, the input may be in two payloads

{
    "foo": "hello"
}

and

{
    "bar": "world"
}

And these are trivially deserializable:

#[derive(Deserialize)]
struct A {
    foo: String,
}

#[derive(Deserialize)]
struct B {
    bar: String,
}

The problem is that the input may be combined

{
    "foo": "hello",
    "bar": "world"
}

And the same model should be constructed in both situations whether the input is combined or not:

struct Model {
    a: A,
    b: B
}

I know before deserialization if the input is combined or split, so creating Model from A and B instances are easy.

The problem is with the combined format is #[serde(flatten)] has many issues (here is one of them), so I need to manually create a flattened struct that is a copy and paste of A and B fields:

impl<'de> Deserialize<'de> for Model {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: serde::Deserializer<'de> {

        #[derive(Debug, JominiDeserialize)]
        struct ModelFlatten {
            foo: String,
            bar: String
        }

        let result = ModelFlatten::deserialize(deserializer)?;
        Ok(Model {
            a: A {
                foo: result.foo
            },
            b: B {
                bar: result.bar
            }
        })
    }
}

The manually flattened deserialization is a not ideal from a maintenance perspective (imagine if A and B had 50 fields each), and may be error prone.

My question is, is this possible with serde_with, or something that would be possible and within scope? Not sure how much leeway there already is with flatten

[jonasbb]

There is nothing for this purpose in serde_with. I do not even know of anything else that would cover it.
Overall, this should be possible with proc-macros. However, designing one that is nice to use might not be as simple. Especially, do you want it to act additive, i.e., generate a ModelFlatten based on the existing definitions of A and B, or do you define a large ModelFlatten and annotate each field and then have the macro create as many sub-structs as needed.

Such a macro could be a suitable addition for serde_with.

[nickbabcock]

do you want it to act additive, i.e., generate a ModelFlatten based on the existing definitions of A and B

Yeah this is the use case I'm targeting, so it's more straightforward when working with the separated payloads.

This is what I envision how this feature would be used in the ideal scenario:

#[derive(Deserialize)]
struct A {
    foo: String,
}

#[derive(Deserialize)]
struct B {
    bar: String,
}

#[derive(DeserializeFlattener)]
struct Model {
    a: A,
    b: B
}

I'm probably papering over a lot of edge cases and difficulties.

[jonasbb]

The problem with the additive approach is that the macro expansion order between structs is undefined. To combat that, you could wrap all three structs in a proc-macro invocation. That macro would parse the struct definitions and rewrite them appropriately. So I think I is possible, but not trivial.

Breaking one struct into multiple would be simpler, because it avoids the cross-struct problem.

[nickbabcock]

Breaking one struct into multiple would be simpler, because it avoids the cross-struct problem

I hadn't considered this, what do you imagine it would look like?

[jonasbb]

I was thinking something like this. You could specify what attributes to apply to the new structs and whatever other things you want to specify.

#[derive(Debug, Serialize)]
struct Model {
	#[extract(struct = "A", attrs = "#[derive(Debug, Serialize)]")]
    foo: String,
	#[extract(struct = "A")]
    foo2: Option<String>,
	#[extract(struct = "B")]
    bar: String,
}

This would create the new structs:

#[derive(Debug, Serialize)]
struct A {
    foo: String,
    foo2: Option<String>,
}
struct B {
    bar: String,
}

[nickbabcock]

That looks good too! Might be a little cumbersome with docstrings, but it seems well worth it