Default tuple argument

[Thaina]

Sometimes tuple argument can expect default value of some field and could be overridden

So I think it would be useful if API provider could

public void SetPoints(params (X:0f,Y:0f,Z:0f)[] points)
{
}

SetPoints(new { X : 1f },new { Y : 1f },new { Z : 1f });

It just using syntax of anonymous object, but actually it would be transpiled into tuple

[DefaultTupleValue("points",0f,0f,0f)]
public void SetPoints(params (float X,float Y,float Z)[] points)
{
}

SetPoints((1f,0f,0f),(0f,1f,0f),(0f,0f,1f));

It should be able to specified default to only some member. And that member will be required

public void SetMovePoints(params (float time,X:0f,Y:0f,Z:0f)[] points)
{
}

SetMovePoints(new { Z : 1f }); // ERROR, need to specified time
SetMovePoints(new { time: 1f,Z : 1f },(2f,1f,0f,1f)); // OK
//// will become => SetMovePoints((1f,0f,0f,1f),(2f,1f,0f,1f));

ps. I just use params as sample but actually I propose this to work with normal tuple argument too

[canton7]

👎 from me -- mixing tuple and anonymous object syntax looks really confusing.

[svick]

If the primary goal is to have succinct syntax for calling the method, wouldn't a custom type combined with target-typed new (#100) be enough? I.e.:

public struct Point
{
    public float X, Y, Z;
    
    public Point(float x = 0, float y = 0, float z = 0) => (X, Y, Z) = (x, y, z);
}

public void SetPoints(params Point[] points)
{
}

SetPoints(new(x: 1f), new(y: 1f), new(z: 1f));

The syntax to declare Point is more verbose than this proposal, but not by that much, especially considering that this probably wouldn't be used that often.

[Thaina]

@svick Because I think I shouldn't need to define a new type just for making a convenient method

@canton7 As for me I just felt like it is implicit conversion between anonymous type and tuple

[canton7]

@Thaina There's no existing implicit conversion between an anonymous type and a tuple though? So you're adding a second new thing to the language, and I object to it.

[Thaina]

@canton7

There's no existing implicit conversion between an anonymous type and a tuple though

That's not the point. I just try to draw a similarity that it could be felt like it was automatically processed as implicit conversion between tuple and anonymous type. Both of it is anonymous object and could be mapped by member's name. So it seemingly convertible. Nothing should felt confused