Rust 如何实现泛型枚举的`Serde：：Desialize`特性

让我们考虑下面的泛型枚举示例:

enum Enum<T, U> {
    T(T),
    U(U),
}

在Enum中实现Serde::Serialize特征相当容易:

impl<T, U> Serialize for Enum<T, U>
where
    T: Serialize,
    U: Serialize,
{
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        match self {
            Enum::T(t) => t.serialize(serializer),
            Enum::U(u) => u.serialize(serializer),
        }
    }
}

然而，我很难实现Serde::Deserialize特征，它的行为应该如下所示:

• 如果该值可以反序列化为类型T，那么它应该返回Enum::T(t).
• 否则，如果该值可以反序列化为类型U，则它应该返回Enum::U(u).
• 否则，它应该返回一个错误.

这是我能得到的最接近的结果:

impl<'de, T, U> Deserialize<'de> for Enum<T, U>
where
    T: Deserialize<'de>,
    U: Deserialize<'de>,
{
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        if let Ok(t) = T::deserialize(deserializer) {
            Ok(Enum::T(t))
        } else {
            if let Ok(u) = U::deserialize(deserializer) {
                Ok(Enum::U(u))
            } else {
                Err(D::Error::custom("Failed to deserialize Enum"))
            }
        }
    }
}

但是，我得到以下错误:

error[E0382]: use of moved value: `deserializer`
   --> src\lib.rs:731:47
    |
724 |         fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    |                           ------------ move occurs because `deserializer` has type `D`, which does not implement the `Copy` trait
...
728 |             if let Ok(t) = T::deserialize(deserializer) {
    |                                           ------------ value moved here
...
731 |                 if let Ok(f) = F::deserialize(deserializer) {
    |                                               ^^^^^^^^^^^^ value used here after move
    |
help: consider further restricting this bound
    |
726 |             D: Deserializer<'de> + std::marker::Copy,
    |                                  +++++++++++++++++++

For more information about this error, try `rustc --explain E0382`.

我知道发生了什么，但我不确定如何修复它(编译器建议也不起作用).