Início / coding / Perguntas / 79134612
Accepted
Satyam Jay
Asked: 2024-10-29 02:04:23 +0800 CST

anotações de tipo necessárias: não é possível satisfazer `T: Deserialize<'_>`

  • 772

Por que esse programa não compila? E como consertar isso? Estou tentando serializar um enum genérico com serde, onde o tipo genérico é serializável.

use serde::{Deserialize, Serialize};

pub trait Row: for<'de> Deserialize<'de> + Serialize + Clone + Send + PartialEq {
    fn key(&self) -> Option<u64> {
        None
    }
    fn timestamp(&self) -> Option<u64> {
        None
    }
}



#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize)]
pub enum MessageContent<R: Row> {
    // Other serializable members
    Data(R),
}


fn main() {
    // Create object of MessageContent and serialize.
}
rust

1 respostas

  1. Best Answer

    O programa não compila devido a um limite de característica redundante resultante da Deserializeexpansão da macro derive.

    Considere o programa muito mais simples:

    use serde::Deserialize;
pub trait Row: for<'de> Deserialize<'de> {}
#[derive(Deserialize)]
pub struct MessageContent<R: Row>(R);

    Se fizermos cargo expandas macros, veremos que Rtem um Rowlimite e um serde::Deserialize<'de>limite (na wherecláusula):

    #[automatically_derived]
impl<'de, R: Row> _serde::Deserialize<'de> for MessageContent<R> where
    R: _serde::Deserialize<'de> { ... }

    Se tentarmos compilá-lo, um erro indicará que essa redundância aparentemente inofensiva não é permitida:

    error[E0283]: type annotations needed: cannot satisfy `R: Deserialize<'_>`
note: multiple `impl`s or `where` clauses satisfying `R: Deserialize<'_>` found

    Para resolver isso, precisamos remover um dos limites redundantes. Para manter seu Rowtrait e MessageContentenum iguais, podemos remover o Deserializelimite extra da macro. Usamos o #[serde(bound(...))]atributo para informar à macro que Rawé o limite que torna Rdesserializável. Observe que for<'de> Deserialize<'de>é melhor escrito como serde::de::DeserializeOwned.

    use serde::{de::DeserializeOwned, Deserialize, Serialize};

pub trait Row: DeserializeOwned + Serialize + Clone + Send + PartialEq {
    fn key(&self) -> Option<u64> { None }
    fn timestamp(&self) -> Option<u64> { None }
}

#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize)]
pub enum MessageContent<R: Row> {
    #[serde(bound(deserialize = "R: Row"))]
    Data(R),
}

    Veja cargo expandcomo fica a nova saída:

    #[automatically_derived]
impl<'de, R: Row> _serde::Deserialize<'de> for MessageContent<R> where
    R: Row { ... }

    Os limites correspondem, o que aparentemente satisfaz o compilador Rust.

    Por fim, só para você saber, colocar limites de características em structparâmetros enumgenéricos não é apenas desencorajado , mas também é uma das causas desse problema.

    Esta versão também funciona e é, sem dúvida, mais idiomática. Ela só não permitiria que você usasse <R as Row>::SomeAssociatedTypedentro do enum:

    use serde::{de::DeserializeOwned, Deserialize, Serialize};

pub trait Row: DeserializeOwned + Serialize + Clone + Send + PartialEq {
    type SomeAssociatedType = u8;
    fn key(&self) -> Option<u64> { None }
    fn timestamp(&self) -> Option<u64> { None }
}

#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize)]
pub enum MessageContent<R> {
    Data(R),
    // Couldn't do this: Data2(<R as Row>::SomeAssociatedType)
}
    • 1

relate perguntas