Can Bytes be combined with FromInto?

[Theodus]

I'd like to deserialize a type that implements From<[u8; _]>. However, it seems like Bytes can't be combined with FromInto the way I expected. I suspect this is because there's no implementation for From<Bytes> for Wrapper, but unfortunately Bytes seems to be an empty type. Am I missing an easy way to accomplish this?

#[test]
fn wat() {
    use serde_with::{Bytes, FromInto};

    #[derive(Clone, Debug)]
    struct Wrapper([u8; 5]);
    impl From<[u8; 5]> for Wrapper {
        fn from(bytes: [u8; 5]) -> Self {
            Self(bytes)
        }
    }

    #[serde_as]
    #[derive(Clone, Debug, Deserialize)]
    struct Test {
        #[serde_as(as = "FromInto<Bytes>")]
        bytes: Wrapper,
    }
}

[jonasbb]

I am unsure what you actually want to achieve. It would help if you could extend your code snippet to a fully runnable example. Using FromInto like you suggest won't work, since Bytes itself cannot be serialized. It does not implement Serialize or Deserialize, which is required for FromInto.

From your snippet it seems what you want to have is this.

#[serde_as]
#[derive(Clone, Debug, serde::Deserialize)]
struct Test {
    #[serde_as(as = "FromInto<[u8; 5]>")]
    bytes: Wrapper,
}

[Theodus]

Yeah, sorry. Here's a full example:

#[test]
fn wat() {
    use serde_with::{serde_as, Bytes, FromInto};

    #[derive(Clone, Debug, Default)]
    struct Wrapper([u8; 5]);
    impl From<[u8; 5]> for Wrapper {
        fn from(bytes: [u8; 5]) -> Self {
            Self(bytes)
        }
    }
    impl From<Wrapper> for [u8; 5] {
        fn from(value: Wrapper) -> Self {
            value.0
        }
    }

    #[serde_as]
    #[derive(Clone, Debug, serde::Deserialize, serde::Serialize)]
    struct Test {
        #[serde_as(as = "FromInto<[u8; 5]>")]
        bytes: Wrapper,
    }
    let test = Test {
        bytes: Wrapper::default(),
    };
    let buf = serde_cbor_2::ser::to_vec(&test).unwrap();
    let cbor: serde_cbor_2::Value = serde_cbor_2::de::from_reader(&buf[..]).unwrap();
    println!("{:?}", cbor);
}

The trouble is that when I run this, the field encoded as an array:

Map({Text("bytes"): Array([Integer(0), Integer(0), Integer(0), Integer(0), Integer(0)])})

But if it were using the inner value & Bytes, it would be serialized as bytes as I want:

    #[serde_as]
    #[derive(Clone, Debug, serde::Deserialize, serde::Serialize)]
    struct Test {
        #[serde_as(as = "Bytes")]
        bytes: [u8; 5],
    }
    let test = Test {
        bytes: <[u8; 5]>::default(),
    };
    let buf = serde_cbor_2::ser::to_vec(&test).unwrap();
    let cbor: serde_cbor_2::Value = serde_cbor_2::de::from_reader(&buf[..]).unwrap();
    println!("{:?}", cbor);

Map({Text("bytes"): Bytes([0, 0, 0, 0, 0])})

[jonasbb]

I see, you really want the behavior of Bytes too. You cannot do that with using FromInto.

I think I would use a helper type like this.

#[serde_as]
#[derive(Clone, Debug, serde::Deserialize, serde::Serialize)]
#[serde(transparend)]
struct FiveBytes {
    #[serde_as(as = "Bytes")]
    bytes: [u8; 5],
}

You can then implement From between FiveBytes and Wrapper. This enables you to directly derive Serialize for wrapper (https://serde.rs/container-attrs.html#from), or if you don't control wrapper, you can use FromInto<FiveBytes>.
Of course you can go one step further and implement SerializeAs/DeserializeAs for the FiveBytes type. Then your annotations are reduced to

#[serde_as(as = "FiveBytes")]
bytes: Wrapper,

[Theodus]

That works. Thank you very much!