Support Construct methods. opposite of Deconstruct.

[MkazemAkhgary]

I found deconstruct often useful in foreach loops.

public static void Deconstruct<TKey, TValue>(this KeyValuePair<TKey, TValue> keyValuePair, out TKey key, out TValue value)
{
    key = keyValuePair.Key;
    value = keyValuePair.Value;
}
//...
foreach((int key, string value) entry in dictionary)
{
}

The opposite could be also useful sometimes. that is going from tuple to single type. why not?

public static void Construct(this (int x, int y) tuple, out long result)
{
    result = tuple.x << 32 | tuple.y;
}

Tuple argument in this method could be generic, how ever out argument needs to be more specific, obviously when you have to initialize result and possibly by passing argument to constructor, however this is just something to keep in mind.

Another more useful example

public static void Construct<T1, T2>(this (T1 x, T2 y) tuple, out MyType result) where T1 : IFoo where T2 : IBar
{
    result = new MyType(tuple.x, tuple.y);
}
//...
foreach(MyType x in source) // a custom enumerator.Current that returns tuple.
{
}

A construct can also be a instance method which could be used instead of calling constructor directly. you would set tuple like this.

public class Point
{
    public static void Construct((int x, int y) tuple, out MyType result)
    {
        result = new Point(tuple.x, tuple.y);
    }
}
//...
Point x = (10, 20);

[jnm2]

We already have constructors and I dislike hiding the new keyword whenever they are used. new should be visible, whatever syntax candy we add.

[jnm2]

I prefer this approach: #100

[MkazemAkhgary]

I prefer this approach: #100

Thats calling Parameter less constructor. Its not equivalent.

In this approach you construct a type from tuple. You could also have additional logics inside construct method.

Why new statement is necessary. This adds syntactic sugar, i liked it btw @jnm2

[jnm2]

@MkazemAkhgary I believe #100 proposal covers parameters, as in Dictionary<string, object> x = new(readOnlyDictionary).

There's no real reason to require a tuple instead of making the parameters part of the argument list, like there would be for returning multiple values. Nor do deconstructors need them; out parameters are good enough. I'd say anything a "Construct" method can do, a constructor can do more idiomatically. You're clear about the fact that you're creating new object instances.

[jnm2]

So concrete examples: IMO Point x = (10, 20); should be Point x = new(10, 20); and at that point #100 covers it.

While tuple enumeration isn't terribly common yet, I think showing the new keyword is highly preferable rather than making it look like the enumerator is returning instances of MyType created by someone else:

foreach (var t in source)
{
    var x = new MyType(t.first, t.second);
    // ...
}

Perhaps you'd be interested in tuple splatting so that you don't have to write .first, .second, etc in the constructor call?

[HaloFour]

Extension everything + implicit operators would probably cover this.

[MkazemAkhgary]

I used a tuple enumerator in my collection since its not simple list. Yes my initial thought was its usage in foreach but then i expanded it into tuple construction thing.

I see, new() with parameters is definitely acceptable. @jnm2

[AustinBryan]

why not?

That's never a good argument for a new feature