为两步 From 制作通用 From/Into 快捷方式

Question

StructA 实现 From<StructB>，StructB 实现 From<S>。

我一般如何实现“快捷方式”Into<StructA> for S 或 From<S> for StructA？

如果这是一个坏主意，请告诉我。但是为了学习，请解释一下如何做。

这是我的尝试：

struct StructA {
    f: StructB
}

struct StructB {
    g: i32
}

impl From<StructB> for StructA {
    fn from(v: StructB) -> Self {
        Self {
            f: v
        }
    }
}

impl From<i32> for StructB {
    fn from(v: i32) -> Self {
        Self {
            g: v
        }
    }
}

impl<T: Into<StructA>, S: Into<T>> Into<StructA> for S {
    fn into(self) -> StructA {
        let i: T = self.into();
        i.into()
    }
}

我得到的错误是the type parameter 'T' is not constrained by the impl trait, self type, or predicates。

我不明白。 T 不是受Into<StructA> 约束吗？

Answer 1

据我所知，这在稳定的 Rust 上是不可能的，因为它需要某种形式的专业化。让我们考虑一下这段代码：

// "StructB -> StructA"
impl From<StructB> for StructA {
    fn from(v: StructB) -> Self {
        Self { f: v }
    }
}

impl From<i32> for StructB {
    fn from(v: i32) -> Self {
        Self { g: v }
    }
}

// "shortcut"
impl<T> From<T> for StructA
where
    StructB: From<T>,
{
    fn from(t: T) -> Self {
        Self::from(StructB::from(t))
    }
}

编译器会抱怨"StructB -> StructA" impl 与"shortcut" impl 冲突。这是真的，因为 From<T> 有一个 blanket implementation 自己。

现在使用Into 根本没有帮助，因为Into 是自反的。所以即使你克服了“不受约束”的错误，你也会回到冲突的实现。

但是！ 这是可能在夜间。通过使用自动特征 (here's a nice article about it) 的一些小技巧，我们可以将“快捷方式”实现限制为仅涵盖不同于 StructB 的类型。

playground link

Answer 2

没有办法产生一个完全通用的解决方案，因为即使您通过“不受约束的类型参数”错误，您也会遇到“冲突的特征实现”错误。这是我所能得到的最接近的结果，它允许将StructB 转换为StructA 或将任何可以转换为StructB 的类型转换为StructA：

#[derive(Eq, PartialEq, Debug)]
struct StructA {
    f: StructB
}

#[derive(Eq, PartialEq, Debug)]
struct StructB {
    g: i32
}

impl From<i32> for StructB {
    fn from(v: i32) -> Self {
        Self {
            g: v
        }
    }
}

impl<T> From<T> for StructA
where
    T: Into<StructB>
{
    fn from(t: T) -> StructA {
        let structb = t.into();
        StructA {
            f: structb
        }
    }
}

fn main() {
    let a1: StructA = StructB { g: 12 }.into();
    let a2: StructA = 12.into();
    assert_eq!(a1, a2);
}

playground

Answer 3

错误消息基本上表明编译器无法推断 T 可能是什么类型 - 它基本上必须弄清楚是否存在任何类型 T 以便满足给定的特征边界 T: Into<StructA>, S: Into<T>，并且这在 Rust 中是不可能的。这样做的一个问题是，如 cmets 中所述，可能有多种类型 T 满足特征边界，在这种情况下编译器无法确定使用哪一种。

此外，Into trait 已经在标准库中有一个全面的实现。

impl<T, U: From<T>> Into<U> for T;

编译器无法保证此 impl 不会与您的一揽子 impl 重叠，这也会使实现模棱两可。

我建议您直接明确地实现From<i32> for StructA。如果您需要许多这样的实现，宏可能会很有用。