rust - 转换为通用类型

Question

我有一个关于 Rust(1.0 版)泛型的新手问题。

假设我编写了一个通用函数来进行除法。别管这种功能的用处；这是一个让这个问题简单化的简单函数。

fn divide<T: std::ops::Div>(a: T, b: T) -> T {
    a / b
}

fn main() {
    println!("{}", divide(42, 18))
}

这个程序编译失败。

src/main.rs:2:5: 2:10 error: mismatched types:
 expected `T`,
    found `<T as core::ops::Div>::Output`
(expected type parameter,
    found associated type) [E0308]
src/main.rs:2     a / b
                  ^~~~~

我知道编译器错误告诉我除法运算的结果是类型 Output，而不是 T，我看到了 Output 输入 standard library documentation .

如何将 Output 转换为 T？我尝试使用 as 进行转换。

fn divide<T: std::ops::Div>(a: T, b: T) -> T {
    (a / b) as T
}

fn main() {
    println!("{}", divide(42, 18))
}

这会导致不同的编译器错误。

src/main.rs:2:5: 2:17 error: non-scalar cast: `<T as core::ops::Div>::Output` as `T`
src/main.rs:2     (a / b) as T
                  ^~~~~~~~~~~~

我没有办法让这项工作发挥作用，而且我意识到我对这里的语言的某些基本知识缺乏了解，但我什至不知道要寻找什么才能使这项工作发挥作用。帮忙？

Answer 1

您只需将 T::Output 指定为函数的返回类型即可:

fn divide<T: std::ops::Div>(a: T, b: T) -> T::Output {
    a / b
}

编辑以添加更多关于为什么不能在函数内进行转换的解释

当您处于通用函数划分中时，编译器还不知道您可以将 T 转换为 T::Output，因此转换无效。它们是泛型类型，它们可以是任何类型，编译器如何知道您可以从 T 转换为 T::Output ？

a/b 产生类型为 T::Output 的东西，所以在上面的解决方案中没有转换，T::Output是正确的类型。

编辑以使用 std::convert::From 添加另一个可能的解决方案

最(我认为)通用的实现是当您知道从 T::Output 到 T 的转换是可能的。您可以绑定(bind) T 以实现 T::Output 的 From。这是一个完整的例子:

use std::ops::Div;
use std::convert::From;

fn divide<T: Div>(a: T, b: T) -> T
    where T: From<<T as Div>::Output>
{
    T::from(a / b)
}

#[derive(Debug)]
struct Bip(u32);

impl Div for Bip {
    type Output = f32;

    fn div(self, rhs: Bip) -> f32 {
        (self.0 / rhs.0) as f32
    }
}

impl From<f32> for Bip {
    fn from(value: f32) -> Self {
        Bip(value as u32)
    }
}

fn main() {
    println!("{:?}", divide(12, 4));
    println!("{:?}", divide(Bip(12), Bip(4)));
}