Rust: 函数的重载——我做的的一组小实验

编程的时候，我发现有不少函数能够根据左值类型自动调用重载函数。但是，我知道 Rust 的函数是不支持重载的。所以我打算尝试一下这一”重载“现象是如何实现的。

一、Rust 不支持函数重载

写一段代码：

fn foo() -> i32 {
    123
}

fn foo() -> String {
    "123".into()
}

fn main() {
    let x: i32 = foo();
    println!("{:?}", x);
    let x: String = foo();
    println!("{:?}", x);
}

无法通过编译，原因是 Rust 不支持重载。

二、泛型函数

试验一下泛型函数，结果 OK！

fn foo<T>(v: T) -> T {
    v
}
fn main() {
    let x = foo(123);
    println!("{:?}", x);
    let x = foo(String::from("123"));
    println!("{:?}", x);
}
======== cargorun ========
123
"123"

但是，这个是通过参数类型来进行函数的实现的。能否根据左值类型自动推断泛型函数的实现方式呢？

三、左值自动推断

泛型函数需要函数体中用到的泛型类型需要具有共同的方法，因此需要定义必要的 trait。我写了个例子，左值自动推断代码如下：

trait MakeValue<T> {
    fn make_value() -> T;
}

impl MakeValue<i32> for i32 {
    fn make_value() -> i32 {
        123
    }
}

impl MakeValue<String> for String {
    fn make_value() -> String {
        "123".into()
    }
}

fn foo<T: MakeValue<T>>() -> T {
    T::make_value()
}

fn main() {
    let x: i32 = foo();
    println!("{:?}", x);
    let x: String = foo();
    println!("{:?}", x);
}
======== cargorun ========
123
"123"

和 C++ 相比， Rust 的泛型机制更为现代和成熟。