# Rust Function Overloading - Call for Experimentation

DevFeed: [Rust Function Overloading - Call for Experimentation](<https://devfeed.tech/articles/rust-function-overloading-call-for-experimentation-15104.md>)

Original publisher: [Read original article](<https://blog.rust-lang.org/inside-rust/2026/08/19/overloading-experiment/>)

Author: teor

Published: 2026-08-19T00:00:00Z

Content type: release

Language: en

Sources: [Inside Rust Blog](<https://devfeed.tech/sources/inside-rust-blog.md>)

Topics: [Rust](<https://devfeed.tech/topics/rust.md>), [C++](<https://devfeed.tech/topics/c-plus-plus.md>), [Compiler](<https://devfeed.tech/topics/compiler.md>), [interoperability](<https://devfeed.tech/topics/interoperability.md>)

Tags: [c-plus-plus](<https://devfeed.tech/tags/c-plus-plus.md>), [compiler](<https://devfeed.tech/tags/compiler.md>), [interoperability](<https://devfeed.tech/tags/interoperability.md>), [languages](<https://devfeed.tech/tags/languages.md>), [rust](<https://devfeed.tech/tags/rust.md>), [syntax](<https://devfeed.tech/tags/syntax.md>)

## AI overview

The Rust Project is experimenting with function and method overloading for FFI bindings through the incomplete nightly "splat" compiler feature. The experiment aims to assess implementation complexity and improve interoperability with C++, while its design may change or be removed.

## Source excerpt

In partnership with the Rust Foundation's Rust-C++ Interop Initiative, the Rust Project has been experimenting with function overloading for FFI bindings. This experiment is now at a stage where compiler and interop tool developers can start exploring function overloading. Stable Rust already supports a form of overloading using tuples and traits, but calling these overloaded functions looks strange, because the overloaded arguments have to be passed as a single tuple argument, like this: hypot((2.0, 3.0, 6.0)). Stable Rust also allows overloading of built-in operators with user-defined types, via traits like Add (the + operator) and Neg (the - value negation operator). We are running an unstable nightly Rust language experiment to answer questions like: How much overloading can we do with Rust's existing trait system? Could this help us call C++ from Rust ergonomically? In the tradition of yeet (to avoid bikeshedding), we are using basic syntax in the first stage of the experiment: the #[rustc_splat] attribute. Alternative syntaxes can be considered later, if the experiment generates useful outcomes. Experimental Function Overloading Rust nightly builds from 2026-07-31 onwards have experimental support for more ergonomic function and method overloading, using the incomplete "splat" compiler feature; if you're a compiler or interop tool developer, we encourage you to experiment with it! This experiment lets overloaded functions be called with separate arguments, like this: hypot(2.0, 3.0, 6.0). No double parentheses required! But type inference and type checking still happen as they would in a stable Rust overload. We are experimenting with splat to get a feel for the complexity of the implementation, and to see if it solves some language interoperability use cases. Like most Rust language experiments, this nightly feature has no RFC, and can change or be removed at any time. Experiment Design We expect the feature to change significantly in future, or to be replace