Enable memberwise operators for tuples

[Rekkonnect]

Summary

Memberwise tulpe operators refer to applying the operator to respective members of same-sized tuples. For example:

var (a, b) = (5, 6);
var (c, d) = (7, 8);
var (e, f) = (a, b) + (c, d);
// equal to
e = a + c;
f = b + d;

These operators will apply to all member types that support the given operators. Tuples whose elements bear different types are also supported, for long as their respective elements support the given operator. In other words, this feature is supported under the given constraints:

Given the tuples t1, t2,

• t1.ItemCount == t2.ItemCount (made-up property; tuple item counts must be equal)
• for i in [0, ItemCount): t1[i] <op> t2[i] must be supported, where t1[i] refers to the i-th item of the tuple

Examples

(int, int) t1
(string, string) t2

t1 + t2 is supported because:

• t1 and t2 both have 2 items each
• t1[0] is int, t2[0] is string, and int + string is a valid operator
• Likewise for t1[1], t2[1]

---

(int, int, string) t1
(int, int, int) t2

t1 - t2 is not supported because for the items at index 2, string - int is not a valid operator.

Consequences

This would also enable compound assignment operators for all the newly supported memberwise tuple operators.

Motivation

Some operations involve memberwise operations on tuples, where respective elements are performed the same operation, yielding the desired result. Be it adding 2D vectors, dividing all by a scalar, or XORing all values by a mask.

Drawbacks

• Tuples are not often used to contain data that operators are used on. This feature would be niche in such occassions.
• Semantically, the operators themselves do not explicitly declare that the operations are performed memberwise. While there are no serious ambiguities for almost all operators (+, -, *, /, ^, |, &, ^, ++, --, !), it wouldn't be straight-forward either, potentially causing confusion to the user.

[giladfrid009]

Thinking point:
could this proposal be used somehow to support direct swapping i.e:

(arr[i], arr[j]) = (arr[j], arr[i])

[FaustVX]

That feature already works fine :
sharplab.io

[giladfrid009]

Oh cool, didn't know that it works.

[FaustVX]

It's not a perfect solution, but you can use the .NET6 preview:
sharplab.io

[Rekkonnect]

It indeed solves part of the problem, but it only solves part of the problem without being directly integrated into the language.

[FaustVX]

Yes, I also would like a language feature instead of my far from perfect solution 😄

[koszeggy]

Be it adding 2D vectors, dividing all by a scalar, or XORing all values by a mask.

Though not that conveniently, but you can already do that with Vector<int> (con: requires 8 ints) and Vector2 structs (con: requires floats). They also have hardware acceleration support.

Otherwise, you can create extension methods as suggested by @FaustVX. It's definitely a better approach than providing some some built-in operator set that would just throw NotSupportedException for non-applicable type arguments.

[Rekkonnect]

Who said it'll throw NotSupportedException? The compiler would simply rewrite the expression and break it down into multiple operations.

Some optimizations could also occur but those aren't the main focus of this proposal.

[hez2010]

You can already partially achieve this with .NET 6: https://sharplab.io/#v2:EYLgtghglgdgPgAQIwDYAEAKAKkgNGrAJgEo0BBAEwoB4d8iA+DbPAktAGwFMAzAF3wt67AE5QA5gAs+pALAAoNErQB3SVxFcCSNCDQBJShSh8oAexgB5AA4aIfMyIDOtVnW0MFy1es1tdBkYm5la2IvaOLkTCwp7yAN5eyggA7Jjc/AB0+nxcYDoA1GhiUnzZufn4GWU5eYRoRSXS5XXEANwKAL4KCgBuECLFXE4Arhx8aAC85FTUALIAnvowAmiLy3xMGAAs+ACsxIK7aCjE7QrImcgAnBiao+Pn8gqaAMaOFGhOfCIjrxPrFYYWATABqEA4Iy4pD0hiowQsNjsDmc8yWK3wgNWWLiiUUyQAzGhkOgsWgzGEIoMChgyU4uBweJj0RMzHxfMQkko8d5vKkvgyeJlwZCtEU2b5hRCoR18UpunK0FziUSSWgoGBrBwoK8TOTKSi1izgSs0P1RaRJgw0DAuCojRsMOaoU8+arUOrNdrdayDY51UCyc7oVNrcGpaLZW7yb0NGIKFpkAAGAhmADKP1g4gwlutIqhmSw6czMGzrsJMbjUATAYmAHEuHwABIQJySADCZgTOdDaHzXEyDebrY7Xa4OdlCoUII0PAgry0cOMpkRftRWDTgvolnZGnoACVhmNNkrFWoNFoN4KAkuEaFkZFaJvGdvdyID0fxnFvOe/Fgd74N5BCu97hCiUTPkyBAAXuBCHg8mzKr+l7wceQHwiBSJgY+V4vtBb4fghuLKhAwDfOE/zEh6WCoeM+oPiINK4TwAp4f+b7km+TydEAA==

The only lacked thing is extension interface implementation so you can implement IAdditionOperators<T, U, V> for ValueTuple<T1, T2>, which may land in C# 11.

[333fred]

I can reasonably confidently say extension interface implementation will not be in C# 11.