Derive serde::Serialize when struct has array as one of it's member

[diva123]

As you can see from the below code that I want to derive Serialize for struct Foo. But since member k is of array type this code gives me error. How do I solve this?

use serde::{Deserialize, Serialize};

#[derive(Serialize, Debug)]
struct Bar {}

#[derive(Serialize, Debug)]
struct Foo {
    k: [Bar; 100],
}

error :
error[E0277]: the trait bound `[Bar; 100]: Serialize` is not satisfied
    --> src/main.rs:57:5
     |
57   |     k: [Bar; 100],
     |     ^ the trait `Serialize` is not implemented for `[Bar; 100]`
     |
     = help: the following implementations were found:
               <[T; 0] as Serialize>
               <[T; 10] as Serialize>
               <[T; 11] as Serialize>
               <[T; 12] as Serialize>
             and 30 others

[H2CO3]

You can:

• just use a Vec instead
• create a newtype wrapper around [Bar; 100] and manually implement Serialize for it by forwarding to the Serialize impl on slices.

[diva123]

@H2CO3

[Bar; 100]

if possible could you please give me a code example for the second solution

[H2CO3]

Something along the lines of (untested):

struct SerializableArray([Bar; 100]);

impl Serialize for SerializableArray {
    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        self.0.as_slice().serialize(serializer)
    }
}

[kornel]

Serde keeps compatibility with old versions of Rust that couldn't deal with arrays of arbitrary size (AKA const generics), so Serde can't either.

There's a workaround crate for this:

serde-big-array

[afetisov]

Is this really a case of low MSRV? I thought that serde and rand don't support generic arrays because they special-cased 0-sized arrays, and thus can't support const generics without either specialization or breaking backwards compatibility.

[kornel]

Ahh, so it's MSRV compatibility issue with a yet-unreleased version of Rust with specialization

[diva123]

Thanks! I think serde-big-array is easiest solution for this