---
title: "Rust Function Overloading - Call for Experimentation"
url: https://daily.dev/posts/rust-function-overloading---call-for-experimentation-fygog582p
source_url: https://blog.rust-lang.org/inside-rust/2026/08/19/overloading-experiment
type: article
source: "Inside Rust Blog"
published: 2026-08-19T15:51:22.871Z
updated: 2026-08-19T20:20:57.477Z
tags: ["rust"]
reading_time: 7
upvotes: 3
comments: 0
language: en
---

> ## Documentation Index
> Fetch the complete documentation index at: https://daily.dev/llms.txt
> Use this file to discover all available pages before exploring further.

# Rust Function Overloading - Call for Experimentation

**[Inside Rust Blog](https://daily.dev/sources/insiderustblog)** · 7 min read · 3 upvotes · 0 comments

## Summary

The Rust Project, in partnership with the Rust Foundation's Rust-C++ Interop Initiative, is experimenting with an unstable nightly feature called "splat" (#[rustc_splat]) that enables more ergonomic function and method overloading, aimed primarily at simplifying FFI bindings to languages like C++. Available on nightly builds from 2026-07-31 onwards, splat lets overloaded functions be called with separate arguments (e.g. hypot(2.0, 3.0, 6.0)) instead of requiring a tuple. The feature is incomplete, unergonomic, and has no RFC yet; recent merges add splat support in rustdoc and for function pointers. Compiler and interop tool developers are invited to experiment and report bugs via the #t-lang/interop Zulip channel.

## Full article

daily.dev links to this article rather than hosting it. Read it at the original source: <https://blog.rust-lang.org/inside-rust/2026/08/19/overloading-experiment>

## Questions this post answers

### How do I call an overloaded C++ function from Rust using the new splat feature?

Use the unstable #[rustc_splat] attribute on a generic function argument bound by a trait implementing the overload logic for each tuple of argument types, then call it with separate arguments like hypot(2.0, 3.0, 6.0) instead of a single tuple. This nightly-only feature, available from Rust nightly builds dated 2026-07-31 onward, still performs standard type inference and checking, but requires enabling #![feature(splat, tuple_trait)] and is combined with a crate like cpp for inline C++ interop.

_daily.dev collects experimental language changes like this splat feature for developers tracking nightly Rust interop work._

### What is the difference between stable Rust tuple based overloading and the new splat feature?

Stable Rust already allows a form of overloading using tuples and traits, but callers must pass all arguments as a single tuple, written as hypot((2.0, 3.0, 6.0)). The new nightly-only splat feature, marked with #[rustc_splat], lets the same overloaded function be called with separate arguments instead, like hypot(2.0, 3.0, 6.0), removing the need for double parentheses while keeping the same type inference and checking behavior.

_developers weighing rust ffi ergonomics can follow splat's progress on daily.dev before it stabilizes._

### Why is the Rust Project experimenting with function overloading for FFI?

The experiment, run in partnership with the Rust Foundation's Rust-C++ Interop Initiative and funded by Google, aims to make calling overloaded foreign functions, such as C++'s std::hypot, more ergonomic from Rust while preserving foreign language maintainability. Design goals include keeping Rust's syntax clean, easing overloaded FFI calls, and selecting the overload resolution most developers would expect, since different languages resolve overloads differently.

_daily.dev surfaces interop initiatives like this for engineers planning cross-language rust and c++ integrations._

---

Tags: [#rust](https://daily.dev/tags/rust)

[View this post on daily.dev](https://daily.dev/posts/rust-function-overloading---call-for-experimentation-fygog582p)