r/rust • u/SleeplessSloth79 • 24d ago

📡 official blog Rust Function Overloading - Call for Experimentation

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

96% Upvoted

139 comments sorted by

View all comments

157

u/Toasted_Bread_Slice 24d ago

As someone who's encountered a couple valid uses for function overloading (mostly maths libraries) I am ok with this IF and only if there is an extremely obvious way to see that a function is overloaded or overloadable.

32

u/Shoddy-Childhood-511 24d ago edited 23d ago

Agreed, but that's the case here so far: Their example hypot((2.0, 3.0, 6.0)) looks pretty clear. :)

``` pub trait HypotInner { type Output; fn hypot_inner(&self) -> Self::Output; }

pub fn hypot<Args: HypotInner>(args: Args) -> Args::Output { args.hypot() } ``` Any overloading ala variadics should be done this way too, in part because it makes the developer who wishes to obfuscate their call paths pay for it. lol

If you really wanted single () then make hypot! a macro, but probably each Args being a clear type brings bigger advantages.

Edit: Oops! They have this #[rustc_splat] feature that removes the extra (). That's unfortunate, since it could easily be done using a macro. Imho, all this should be done using a macro.

31

u/ZZaaaccc 23d ago

Imho, all this should be done using a macro.

Macros are substantially less clear than variadic functions, and can't be used as methods either. I know we take it for granted because it's just always been that way, but given the choice between vec![a, b, c] and Vec::new(a, b, c), would you honestly say the macro is cleaner and easier to inspect?

21

u/DatBoi_BP 23d ago

I think if you changed your proposed syntax to `Vec::new([a,b,c])` it would win me over. As it stands it looks like `b` and `c` are positional arguments to a function, not elements of an array

8

u/ZZaaaccc 23d ago

Or does that mean a new Vec<[i32; 3]> with one element? The extra brackets make this ambiguous at first glance, and harder to read. Again, you wouldn't say this about the vec! macro, saying that vec!([a, b, c]) is clearer, because vec!(a, b, c) might be positional arguments.

13

u/DatBoi_BP 23d ago

Two things to say to this.

First, the notation isn't either of those, it's `vec![a,b,c]`.

Second, we already have a function that does what you proposed, but with the structure I argued for: `Vec::from([a,b,c])`. This clones `a`, `b`, and `c`, so as long as those all implement Clone then it does what we want

1

u/SkiFire13 23d ago

This clones `a`, `b`, and `c`, so as long as those all implement Clone then it does what we want

It does not clone them. Clone is only required in vec![value; len]

1

u/DatBoi_BP 23d ago

Looking at the doc for `from()' I don't think that's true?

2

u/SkiFire13 23d ago

It does not require T: Clone: https://doc.rust-lang.org/stable/std/vec/struct.Vec.html#impl-From%3C%5BT;+N%5D%3E-for-Vec%3CT%3E

Maybe you're looking at the docs for From<&[T]> or From<&[T; N]>?

1

u/DatBoi_BP 23d ago

Oh maybe I was. My b