Rust nightly adds experimental function overloading for FFI ergonomics

Rust’s nightly compiler has introduced an experimental feature for function overloading, aimed at improving ergonomics when calling foreign functions, particularly from C++. The feature uses the `#[rustc_splat]` attribute to allow overloaded functions to accept separate arguments, eliminating the need for tuple-wrapped parameters. This is a departure from stable Rust’s current approach, where overloading is achieved through traits and tuples, resulting in less intuitive syntax like `hypot((2.0, 3.0, 6.0))`. The experiment is explicitly framed as a way to explore whether Rust’s trait system can accommodate more flexible overloading without compromising the language’s design principles.

The primary motivation for this experiment is to simplify FFI bindings, especially for C++, which relies heavily on function overloading. The current implementation is minimal and intentionally avoids bikeshedding by using a placeholder syntax (`splat`). This approach allows the Rust team to assess the complexity of the implementation and its practical utility before committing to a final design. However, the feature is incomplete and unstable, meaning it could change significantly or be removed entirely. Engineers working on interop tools or compiler internals are encouraged to experiment with it, but production use is not recommended at this stage.

The experiment’s design axioms prioritize preserving Rust’s ergonomics and maintainability while making FFI calls easier. This is a challenging balance, as different languages have varying overload resolution rules. For example, the example provided demonstrates how Rust can call C++’s `std::hypot` with either two or three arguments, but the implementation requires manual trait definitions for each overload. This adds boilerplate and complexity, which the Rust team aims to reduce in future iterations. A macro-based approach is already in development to simplify this process, but it remains a work in progress.

Current limitations include the feature’s instability, its reliance on nightly builds, and the lack of proper rustdoc support for splatted arguments. The latter was only recently merged and displays arguments as an ellipsis (`…`), which is not ideal for documentation. Additionally, the experiment does not yet address all edge cases, such as type inference or compatibility with existing Rust traits. Engineers interested in testing the feature should be prepared for breaking changes, as the Rust team has not committed to a final design or even a long-term roadmap for this functionality.

For engineers working on FFI tooling, this experiment offers an early glimpse into how Rust might handle overloading in the future. The potential benefits include cleaner, more intuitive code when interfacing with C++ and other languages. However, the current implementation is far from production-ready, and its long-term viability depends on community feedback and further development. Those experimenting with the feature should focus on identifying pain points and use cases that the Rust team may not have anticipated, as this will shape the final design.