Allow to flatten sequences/tuples

[Mingun]

It will be useful to allow flatten sequences, especially that will very helpful to model of XSD choice types.

Example for JSON (but it's not as expressive as for XML): Playground

use serde::{Deserialize, Serialize};

#[derive(Debug, PartialEq, Serialize, Deserialize)]
enum Enum { A, B, C }

#[derive(Debug, PartialEq, Serialize, Deserialize)]
struct List {
    #[serde(flatten)]
    items: Vec<Enum>,
}

#[test]
fn ser() {
    let list = List {
        items: vec![
            Enum::A,
            Enum::C,
            Enum::B,
        ]
    };
    assert_eq!(
        quick_xml::se::to_string(&list).unwrap(),
        r#"<List><A/><C/><B/></List>"#
    );
    // Currently failed with
    // "can only flatten structs and maps (got a sequence)"
}

#[test]
fn de() {
    let list: List = quick_xml::de::from_str(r#"
      <List>
        <A/>
        <C/>
        <B/>
      </List>
    "#).unwrap();
    assert_eq!(
        list,
        List {
            items: vec![
                Enum::A,
                Enum::C,
                Enum::B,
            ]
        }
    );
    // Currently failed with
    // "can only flatten structs and maps"
}

[praseodym]

Flattening is possible in combination with EnumMap from serde_with. Example:

use serde_with::EnumMap;

#[serde_with::serde_as]
#[derive(Serialize, Deserialize)]
struct VecEnumValues (
    #[serde_as(as = "EnumMap")]
    #[serde(flatten)]
    Vec<EnumValue>,
);

[cathaysia]

I expect flat a vec shoule be like this:

struct A{
   #[serde(flatten)]
   data: Vec<int>
}


fn main(){
    let a = A { 
        data: vec![1,2,3,4,5]
    };
    // ser a, then a should be 
    // A {
    //    data: 1,
    //    data: 2 ,
    //    data: 3,
    //    data: 4,
    //    data: 5
    // }
    //
}