PR

[memoryleak47]

No description provided.

[RustyYato]

    fn addition(*arg: (u32, u32)) -> u32 {
        arg.0 + arg.1
    }

I would add a code snippet showing how this is used, because my first reaction to seeing this was: this isn't doing anything new. Something like:

assert_eq!(addition(2, 3), 5);

Also, shouldn't the * be on the type? Otherwise, it looks like it's part of a pattern. If it is part of the pattern, can it be used elsewhere? Looks like no, because .. used in patterns for tuple types. In that case shouldn't we use .. in function calls, to signify variable length arguments? For consistency. After all this, having *T in type parameters sticks out like a sore thumb, so that too should be changed to use .. also for consistency (that way seeing .. means ranges or tuple types). But .. conflicts with ranges, so I think it would be better to have ... or some other sigil.

[mehcode]

Personally I feel * conflicts (mentally) with pointers too much. E.g.. *T wouldn't work as people expect that to be a raw pointer.

I strongly feel ... would be a better fit.

• ... in patterns is deprecated in Rust 2018
• ...x is currently illegal (unlike *x)
• extern "C" { fn print(_: u32, ...); } is currently stable for foreign functions

---

// Definition (slightly prefer the second)
fn addition(...arg: (u32, u32)) -> u32 { }
fn addition(arg: ...(u32, u32)) -> u32 { }

// Call
addition(10, 20);
addition(...(10, 20));

[dlrobertson]

Are you still working on this? I was going to start working on an RFC for variadic generics, but then I noticed your pre-RFC.

[memoryleak47]

Not actively.
Feel free to create an RFC yourself.