Can Rust Also Play Function Overloading?

Rust does not directly support traditional object-oriented language function overloading (i.e., dispatching functions with the same name based on parameter types or counts).

// The following cannot coexist
Bar::foo(1);
Bar::foo(1, 2);

Is there a way to simulate this? One approach is to use trait + tuples.

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

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

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

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

By using tuple lengths, we can simulate different parameter counts to achieve an effect similar to “overloading”:

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

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

Although this method achieves a similar effect to overloading, it requires additional parentheses (tuple syntax), which makes it less intuitive. So, is there a way to remove these parentheses?

extern “rust-call” and unboxed_closures

extern "rust-call" is a key mechanism in Rust’s closure implementation, used to automatically pack parameter lists into tuples. For example:

// Closure calls are equivalent to:
let closure = |a, b| a + b;
closure(1, 2); // Actual call: closure.call((1, 2))

When calling a closure, parameters (1, 2) are implicitly packed into a tuple (i32, i32) and passed via the extern "rust-call" convention. This syntax is typically used to manually implement Fn, FnMut, FnOnce traits, or interact with compiler internals.

However, this feature is not available in the stable Rust version; we must switch Rust to the nightly version and enable the unboxed_closures and fn_traits features.

#![feature(unboxed_closures, fn_traits)]

Now, the magic begins. We can define a struct and implement the FnOnce trait for it to simulate function overloading with different parameter counts:

pub struct example;

// Implement FnOnce for single parameter
impl FnOnce<(&str,)> for example {
    type Output = String;

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

// Implement FnOnce for double parameters
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)
    }
}

When calling, parameters can be passed directly without tuple syntax:

// The following code works correctly
fn main() {
    let r = example("f");
    println!("{}", r); // f
    let r = example("f1", "f2");
    println!("{}", r); // f1,f2
}

If you don’t understand the above code, you can think of fn as syntactic sugar for a struct and some trait implementations. For example, fn example(arg1: &str, arg2: &str) -> String {…} can be seen as a struct Example and its corresponding FnOnce implementation.

Conclusion

While the above methods can achieve effects similar to function overloading, these techniques are not recommended best practices in Rust. Rust’s design philosophy favors explicitness and type safety. Therefore, even if it means writing multiple function names for different parameter counts, it might be a better choice. This results in clearer and more readable code, aligning better with Rust’s design principles.

Imagine having two overloaded versions of a function, one accepting one parameter and another accepting two. If you suddenly need to add a new parameter to both versions, global replacements can introduce potential issues. Thus, writing distinct function names for different parameter counts reduces the mental burden on maintainers and improves code maintainability.

In summary, Rust provides various flexible ways to achieve effects similar to function overloading, but in actual development, explicit is better than implicit, and clear code structure is often more valuable than clever tricks.