如何从Rust的opaque type中获取具体类型？

我写了一段Rust代码，因为函数返回的不透明类型隐藏了真实类型，导致无法将返回的整数和其他整数执行加法操作：

use std::fmt::Display;

fn fx<T: Display>(x: T)-> impl Display {
    x
}

fn main() {
    let y: i32 = fx(10);
    let xy =  y + 10;
    println!("Hello World {}", xy);
}

运行后得到错误：

error[E0308]: mismatched types
  --> main.rs:16:18
   |
10 | fn fx<T: Display>(x: T)-> impl Display {
   |                           ------------ the found opaque type
...
16 |     let y: i32 = fx(10);
   |            ---   ^^^^^^ expected `i32`, found opaque type
   |            |
   |            expected due to this
   |
   = note:     expected type `i32`
           found opaque type `impl std::fmt::Display`
error: aborting due to 1 previous error
For more information about this error, try `rustc --explain E0308`.

解决方案 #

1. 让不透明类型暴露所需操作的 trait 约束

如果需要对返回值执行加法，除了Display，还要让返回的不透明类型满足Add trait，同时保留原始类型的关联信息：

use std::fmt::Display;
use std::ops::Add;

fn fx<T>(x: T) -> impl Display + Add<Output = T>
where
    T: Display + Add<Output = T>,
{
    x
}

fn main() {
    let y = fx(10);
    let xy = y + 10;
    println!("Hello World {}", xy);
}

这里不需要显式指定y的类型为i32，编译器会通过Add约束推断出类型，同时支持加法操作。

2. 显式转换类型（仅当确定具体类型时使用）

如果你明确知道函数返回的真实类型，可以用as或者TryInto进行类型转换：

use std::fmt::Display;
use std::convert::TryInto;

fn fx<T: Display>(x: T)-> impl Display {
    x
}

fn main() {
    // 当确定返回值是i32时，用as强制转换
    let y = fx(10) as i32;
    let xy = y + 10;
    println!("Hello World {}", xy);

    // 或者用TryInto做安全转换
    let y: i32 = fx(10).try_into().unwrap();
    let xy = y + 10;
    println!("Hello World {}", xy);
}

注意：这种方法依赖于你对返回类型的确定性，如果后续函数返回类型改变，代码会报错。

3. 直接返回泛型类型而非不透明类型

如果不需要隐藏返回类型，直接返回泛型T即可，这样就能完全保留原始类型的所有特性：

use std::fmt::Display;

fn fx<T: Display>(x: T) -> T {
    x
}

fn main() {
    let y: i32 = fx(10);
    let xy = y + 10;
    println!("Hello World {}", xy);
}

这种方式最直接，适合不需要隐藏类型的场景。

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