Rust 也能玩函数重载？

Rust 本身不直接支持传统面向对象语言中的函数重载（即同名函数根据参数类型或数量不同自动分派）。

//下面是不能同时存在的
Bar::foo(1)
Bar::foo(1,2)

那有没有办法模拟呢？一个比较接近的写法是使用 trait + 元组。


pub trait Reader {
    fn read(&self)->String;
}

impl Reader for (&str,) {
    fn read(&self)->String {
        return self.0.into();
    }
}

impl Reader for (&str,&str,) {
    fn read(&self)->String {
        return format!("{},{}", self.0, self.1);
    }
}

fn read_str<R: Reader>(f: R) -> String {
    f.read()
}

在调用上，就可以通过元组的长度来模拟参数的个数来实现“参数重载”的效果：

fn main() {
    let r = read_str(("read",));
    println!("{}", r);

    let r = read_str(("read1","read2",));
    println!("{}", r);
}

这种方法虽然实现了类似重载的效果，但调用时需要额外的小括号（元组语法），使用起来不够直观。那么，有没有办法去除这些小括号呢？

extern “rust-call” 与 `unboxed_closures`

extern "rust-call" 是 Rust 闭包底层实现的关键机制，用于将 参数列表自动打包为元组。例如：

// 闭包的调用相当于：
let closure = |a, b| a + b;
closure(1, 2); // 实际调用：closure.call((1, 2))

当调用闭包时，参数 (1, 2) 会被隐式打包成一个元组 (i32, i32)，并通过 extern "rust-call" 约定传递。这个语法通常用于手动实现 Fn、FnMut、FnOnce trait，或与编译器内部机制交互。

但是，这个特性在 rust stable 版本中是无法使用的，我们必须把 rust 切换到 nightly 版本,并启用 unboxed_closures 和 fn_traits 特性

#![feature(unboxed_closures,fn_traits)]

好了，魔法开始。我们可以定义一个结构体，并为它实现 FnOnce trait，从而模拟不同参数数量的函数重载：

pub struct example;

// 为单参数实现 FnOnce
impl FnOnce<(&str,)> for example {
    type Output = String;

    extern "rust-call" fn call_once(self, args: (&str,)) -> Self::Output {
        args.0.into()
    }
}
// 为双参数实现 FnOnce
impl FnOnce<(&str,&str)> for example {
    type Output = String;

    extern "rust-call" fn call_once(self, args: (&str,&str)) -> Self::Output {
        format!("{},{}", args.0, args.1)
    }
}

调用时，可以直接传递参数，而无需使用元组语法：

// 下面的代码能正确运行
fn main() {
    let r = example("f");
    println!("{}",r);//f
    let r = example("f1","f2");
    println!("{}",r);// f1,f2
}

如果不理解上面的代码，可以将 fn 看作是结构体和一些 trait 实现的语法糖。例如，fn example(arg1: &str, arg2: &str) -> String {…} 可以看作是一个结构体 Example 和对应的 FnOnce 实现。

最后

虽然上述方法可以实现类似函数重载的效果，但这些技巧并不是 Rust 推荐的最佳实践。Rust 的设计哲学更倾向于显式和类型安全，因此即使需要为不同参数数量编写多个函数名，也可能是更好的选择。这样代码更清晰，可读性更高，也更符合 Rust 的设计理念。

想象一下，如果一个函数有两个重载版本，一个接受一个参数，另一个接受两个参数。突然你需要在这两个版本中都添加一个新参数，那么全局替换时可能会引入潜在的问题。因此，为不同参数数量编写明确的函数名，反而能减少维护者的心智负担，提高代码的可维护性。

总之，Rust 提供了多种灵活的方式来实现类似函数重载的效果，但在实际开发中，显式优于隐式，清晰的代码结构往往比“奇技淫巧”更有价值。

Rust 也能玩函数重载？

extern “rust-call” 与 unboxed_closures

最后

extern “rust-call” 与 `unboxed_closures`