转换为泛型类型

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，我在standard library documentation 中看到Output 类型。

如何从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 的转换是可能的。您可以绑定T 以实现From 为T::Output。 这是一个完整的例子：

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)));
}

Answer 2

Andreas 的回答解释了为什么强制转换是不可能的，并且使函数尽可能通用可以解决这个问题。

然而，这不是唯一的解决方案。 Rust 还支持约束泛型函数的关联类型（此处为Output）。

另一种选择是：

use std::ops::Div;

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

<Output = T> 位指示编译器仅在此函数中接受 T 类型，Div 的实现具有等于 T 的 Output。这显然更具限制性，但它允许确保divide 的结果是T 类型。