Tuple types in using directives

[gafter]

It has been requested that we support

using Subject = (bool Gender, double Age);

[HaloFour]

🍝 Generic version when combined with #3993?

using Subject<T> = (T Gender, double Age);

[iam3yal]

That's pretty cool!

[DavidArno]

At first glance, this seems an excellent idea. But then it takes on the texture of "aerosol cream": it looks like rich, thick, real cream but turns out to be 90% air. Yes, it would be useful occasionally, but the scope would then just be within that file. Some means of giving it a wider scope would really make this useful, eg:

Subject.cs

public global Subject<T> = (T Gender, double Age);

OtherFile.cs

bool GetGender(Subject<bool> subject) => subject.Gender; 

var gender = GetGender((false, 10));

Update
Having thought though this topic, I now feel that @alrz's point re records is pertinent. There should be no need for tuple aliases when we have records. So I no longer think this a useful feature at all.

[dsaf]

@DavidArno this was previously rejected for some reason #7451.

[DavidArno]

@dsaf,
That's a shame, but thanks for the link.

[MgSam]

I'm happy with the proposal as @gafter specified. I think generics and global scope are both orthogonal to this feature and should be considered separately.

[DavidArno]

Generics and global scope are enhancements to the basic proposal. So you appear to be misusing the term "orthogonal" 😛

[MgSam]

@DavidArno They are completely separable proposals that do not impact the merits of this feature as proposed. I'd call that orthogonal. Scope creep is the death of feature requests.

[qrli]

I don't see this necessary. It is at best low priority.

If you want a type, define a type.

[alrz]

Once we have records, it'll be a piece of cake.

struct Subject(bool Gender, double Age);

I'd personally prefer to have generic and global type aliases over this.

[orthoxerox]

@DavidArno records do not cover all the use cases you might need aliases for. See my example in #7453, there's no way a record can replace a long-winded generic interface type declaration.

[DavidArno]

@orthoxerox,

Apologies, my comment wasn't clear. I was referring to this specific feature request: tuple aliases, not type aliases in general. I've updated my comment to fix that.

[alrz]

@DavidArno I'm saying that when you want a named tuple you'd better to define a struct record. But generic and global type aliases are useful for other scenarios, regardless of this proposal.

[AdamSpeight2008]

Will the diposable form of using also be supported.

using ( ( MyDisposable0, MyDisposable1 ) )
[
  ...
}

[alrz]

@AdamSpeight2008 This is already supported:

using (IDisposable d1 = e1, d2 = e2) {}

Also see #9882 and #11420.

[AdamSpeight2008]

@alrz That's not what I'm asking.
Let's we have this function.

Function Foo(Of T As IDisposable(Of T), U As IDisposable(Of U)) () As ( T, U )
End Function

And it is call within the header of a using block.

using( Foo() ) { ... }
 // Will both part of the Tuple<T,U> be disposed?

Do the Tuple<T,U> dispose correctly the disposable items within the tuple? eg .Item1 , .Item2

[HaloFour]

@AdamSpeight2008

#9882

[AdamSpeight2008]

@HaloFour If the tuple is decomposed into separate variables, we risk the chance of disposing of a copy.

[HaloFour]

@AdamSpeight2008

That proposal goes over several potential implementations. Either way, this proposal is about using for aliases, not using for disposables. #9882 is about using for disposables and how that might relate to tuples, if at all.

[jcouv]

@gafter Should this be moved to csharplang?

[gafter]

@jcouv yes, I'll move it.

[gafter]

Issue moved to dotnet/csharplang #423 via ZenHub