为何在T: Into<U>约束下无法使用U::from？（Rust类型转换问题）

我想实现简单的温度类型转换，编写了如下Rust代码：

struct Celsius(f64);
struct Fahrenheit(f64);

impl From<Celsius> for Fahrenheit {
    fn from(c: Celsius) -> Self {
        Fahrenheit(c.0 * 9. / 5. + 32.)
    }
}

impl From<Fahrenheit> for Celsius {
    fn from(f: Fahrenheit) -> Self {
        Celsius((f.0 - 32.) * 5. / 9.)
    }
}

fn danger_of_freezing<T: Into<Celsius>>(temp: T) -> bool {
    let celsius = Celsius::from(temp);
    celsius.0 < 0.0
}

fn main() {
    danger_of_freezing(Celsius(20.0));
    danger_of_freezing(Fahrenheit(68.0));
}

但编译器报错：

error[E0277]: the trait bound `Celsius: From<T>` is not satisfied
  --> src\main.rs:17:33
   |
17 |     let celsius = Celsius::from(temp);
   |                   ------------- ^^^^ the trait `From<T>` is not implemented for `Celsius`
   |                   |
   |                   required by a bound introduced by this call
   |
help: consider introducing a `where` clause, but there might be an alternative better way to express this requirement
   |
16 | fn danger_of_freezing<T: Into<Celsius>>(temp: T) -> bool where Celsius: From<T> {
   |                                                          ++++++++++++++++++++++

我明白From和Into trait相关联，实现From会自动实现Into，但不理解为何第一种写法无法工作。我知道改用如下代码可以正常编译，但仍有疑惑：

fn danger_of_freezing<T: Into<Celsius>>(temp: T) -> bool {
    let celsius: Celsius = temp.into();
    celsius.0 < 0.0
}

问题根源：From与Into的约束逻辑差异 #

首先明确Rust标准库的规则：当为类型U实现From<T>时，会自动为T实现Into<U>，但反过来不成立——T: Into<U> 并不等价于 U: From<T>。

你的函数签名是T: Into<Celsius>，这只保证了T具备转换为Celsius的能力，但不代表Celsius一定实现了From<T> trait。虽然大部分场景下两者是配套的，但从 trait 约束的逻辑上，Into<U>的实现完全可以手动编写，不需要依赖From<T>的自动推导。

两种写法的本质区别

• temp.into()：调用的是T自身实现的Into<Celsius>方法，这正好匹配函数签名里的T: Into<Celsius>约束，编译器能直接找到对应实现。
• Celsius::from(temp)：调用的是Celsius类型上的From<T>方法，但你的函数签名没有对Celsius: From<T>做约束，编译器无法保证所有满足T: Into<Celsius>的类型都能被Celsius::from处理。

为什么测试用例符合却仍报错？

你为Fahrenheit实现了From<Fahrenheit> for Celsius，自动得到Fahrenheit: Into<Celsius>；同时标准库为所有类型默认实现了From<T> for T，所以Celsius: Into<Celsius>也成立。但编译器处理泛型函数时，会要求它对所有满足约束的类型都能工作，而不是只针对你测试的两个类型。

假设有某个类型T手动实现了Into<Celsius>，但没有让Celsius实现From<T>，那你的第一种写法就会失效，因此编译器不允许这种写法。

内容的提问来源于stack exchange，提问作者kik3r