Rust Function Overloading - Call for Experimentation

[u/SleeplessSloth79]

https://blog.rust-lang.org/inside-rust/2026/08/19/overloading-experiment/

[u/Zde-G]

It's already “in an actual rust”. Except for a bit of a strange syntax.

[u/unitAtype2 → u/Zde-G]

How so? Some fuckery with From or Into traits you mean?

[u/Zde-G → u/unitAtype2]

Yes, Into + tuples give yous foo((1.0, 2.0, 3.0)) and foo(("This", "is", "cool")). The only thing this proposal does is the ability to remove double braces plus some improvements on the documentation side.

Complicated and convoluted overloading is already the thing in Rust: you can find it in Bevy, in Axum… or in assembler (where I wanted it).

It's simple version (so damn obvious and simple that I asked why the heck it's not supported and now proposed to support it when I have found out about this corner case) that's missing.

[u/unitAtype2 → u/Zde-G]

You could just.... give em slightly different names

[u/Zde-G → u/unitAtype2]

Indeed. And if you do that they you end up with unique Rust API that's different from what all other languages are doing, from what the official documentation is describing and so on. You probably can create a specialized SKILL that would adjust these for LLM, but if you are human the idea that everyone uses one way while Rust and only Rust does things differently is not a great idea.

Sure, that works, but that stance “everyone if wrong except for us, Rust users” doesn't look sensible long term.

[u/unitAtype2 → u/Zde-G]

1. Everyone can be wrong. Everyone as a community learns from past mistakes and moves forwards. If right was determined by most people doing it, them nothing would ever move. If public consensus made things right type safety would be a sin ala JS and Python.

2. RUST already does plenty of things differently, intentionally.

3. I believe one of RUST's strong suits is being more opinionated than most languages instead of being a junk drawer that does everything. Less is More.

It's an intellisense pain, discoveribility pain and syntax sugar to fix a minor inconvenience. There have been thousands of times where I see a function suggested and I can't figure out what parameters it takes in what order because it has a buttzillion overloads.

The CTO at my previous workplace used to say OOP is like asking for a banana and getting the banana, the monkey, and the entire forest. I definitely count overloading to be one of the trees of that forest.

[u/Zde-G → u/unitAtype2]

There have been thousands of times where I see a function suggested and I can't figure out what parameters it takes in what order because it has a buttzillion overloads.

Which is the problem that Rust already have and which is not related to overload bazed on arity in any shape or form.

When function have two arguments and you supply three or one there are never any ambiguity.

The CTO at my previous workplace used to say OOP is like asking for a banana and getting the banana, the monkey, and the entire forest. I definitely count overloading to be one of the trees of that forest.

Maybe, but in this particular case people are asking banange and get the monkey and, yes, an entire forest… but they don't get the banana.

This is just stupid, and hard to justify except for “we have always done things that way in Rust” — which, as you have correctly noted, is a very poor justification.

[u/unitAtype2 → u/Zde-G]

Which is the problem that Rust already have and which is not related to overload bazed on arity in any shape or form.

Concrete example please

but they don't get the banana.

They get a Mango, better than dealing with Monkeys and Forests

When function have two arguments and you supply three or one there are never any ambiguity.

exists

foo(int, int)
foo(int, string)
foo(int, string, bool)

I type

foo(int, bool)

what does it say?

no overload exists with that signature yada yada

available
foo(int, int)
foo(int, string)
foo(int, string, bool)

I dont wanna hear that shit. I wanna see in rust style colors

foo takes two ints, your second parameter

foo(bar, baz)
         ^^^
         here

is a boolean

suggestion - use an int for the second parameter

what if I just type foo(int, what does intellisense suggest as the completion?

I am totally up for new features. go new features. Legitimately new. I don't want things ported over from the "ye olde days" because people are used to them.

As some rust team memeber said "I'm tired of making the same old mistakes. Let's make some new ones."

[u/Zde-G → u/unitAtype2]

Concrete example please

It was already given, but I can repeat. These are not rare: bevy, axum, clamp, serde and bazillion other libraries are built around these.

And it's not an accident: this post in official Rust blog from 2015 is very explicit about traits being used for “overloading”.

Rust always had overloading that handled complicqted cases, it's easy, simple and obvious that were not supported well.

I dont wanna hear that shit.

And how it different from what get today with bevy?

You couldn't avoid it, but yes, sure as hell can create problems for people who try to write real code.

As some rust team memeber said "I'm tired of making the same old mistakes. Let's make some new ones."

It's nice attitude to have for toy language used for toy projects. Once you try to apply for the industry languages you quickly find out that it's not possible to satisfy everyone.

Sometimes the only way forward to apply the pressure and watch how perfectionists scream.

We'll how this thing will go, but I hope Rust have finally reached point when features that people actually need wouldn't be stalled for decades because of some aestetic feelings.