as_serde_tuple.rs

extern crate serde; // 1.0.80
use serde::{Deserialize, Deserializer, Serialize, Serializer};

// Used to deserialize a struct as a tuple.
extern crate serde; // 1.0.80
use serde::{Deserialize, Deserializer, Serialize, Serializer};

// Used to deserialize a struct as a tuple.
macro_rules! as_serde_tuple {
    ($(#[$smeta:meta])*
        $svis:vis struct $sname:ident {
            $($fvis:vis $fname:ident : $ftype:ty,)*
    }) => {
        $(#[$smeta])*
        $svis struct $sname {
            $($fvis $fname : $ftype,)*
        }
       
        impl<'de> Deserialize<'de> for $sname {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
                where D: Deserializer<'de>
            {
                #[derive(Deserialize, Serialize)]
                pub struct Array($(pub $ftype,)*);

                Deserialize::deserialize(deserializer)
                    .map(|Array($($fname,)*)| Self { $($fname: $fname,)* })
            }
        }
        
        impl Serialize for $sname {
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
            where
                S: Serializer,
            {
                #[derive(Deserialize, Serialize)]
                pub struct Array($(pub $ftype,)*);

                (Array($(self.$fname.clone(),)*)).serialize(serializer)
            }
        }
    }
}

// Usage example :
as_serde_tuple! {
#[derive(Debug)]
struct Array17 {
    field1: String,
    field2: i64,
    field3: Option<i32>,
    field4: i32,
    field5: i32,
    field6: i32,
    field7: i32,
    field8: i32,
    field9: i32,
    field10: i8,
    field11: i32,
    field12: i32,
    field13: i32,
    field14: i32,
    field15: i32,
    field16: i32,
    field17: i32,
}
}

fn main() {
    let j = r#"
        ["1", 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17]
    "#;
    let array = serde_json::from_str::<Array17>(j).unwrap();
    println!("{}", serde_json::to_string(&array).unwrap());
}