Proposal: Concepts

[hez2010]

Motivation

With the introduction of virtual static methods, we are now using more and more generic programming with generic constraints. This leads to an issue where you have to repeat the generic constraints again over again which leads to a lot of bloats.

Take an example in .NET BCL: https://github.com/dotnet/runtime/blob/6bbf3520b7232e19c2d1c4d59631a318199f847d/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.op_Multiply.cs#L6

We end up duplicating the generic constraints where T : IMultiplyOperators<T, T, T>, IMultiplicativeIdentity<T, T> again and again, which produces to a lot of boilerplate code.

A solution is to create yet another interface interface IMultiplyOperatorsWithMultiplicativeIdentity<T> : IMultiplyOperators<T, T, T>, IMultiplicativeIdentity<T, T>, and use IMultiplyOperatorsWithMultiplicativeIdentity<T> instead.

However, it's really not a solution as it immediately requires all the types to implement the new interface, otherwise you cannot pass it to a generic parameter that is constrained by the new constraint.

Proposal: Concepts

Concepts are an alias of a set of operations. Unlike interfaces, concepts don't have the type identity, and they can only be used as generic constraints.

We use concept Name<TypeParams> = TypeList to declare a concept:

public concept MultiplyOperatorsWithMultiplicativeIdentity<T> = IMultiplyOperators<T, T, T> & IMultiplicativeIdentity<T, T>;

while I'm here just throwing an example, the final syntax doesn't have to be like this. But I chose this syntax because it can express conjunction relation with & explicitly while also reserving the space for future update in case we want to extend it to support disjunctive relation with | in the future.

We can also "extend" an existing concept by:

public concept Foo<T> = MultiplyOperatorsWithMultiplicativeIdentity<T> & IAdditionOperators<T, T, T>;

Then to use a concept, we simply do:

public static T Bar<T>(T x) where T : Foo<T>
{
    return (x + x) * x;
}

Lower strategy

Definitions

For concept definitions, we can lower it to some unspeaking types. For example,

public concept MultiplyOperatorsWithMultiplicativeIdentity<T> = IMultiplyOperators<T, T, T> & IMultiplicativeIdentity<T, T>;

gets lowered to

[Concept]
public static class <Concept>MultiplyOperatorsWithMultiplicativeIdentity<T> : IMultiplyOperators<T, T, T>, IMultiplicativeIdentity<T, T>;

and

public concept Foo<T> = MultiplyOperatorsWithMultiplicativeIdentity<T> & IAdditionOperators<T, T, T>;

gets lowered to

[Concept]
public static class <Concept>Foo<T> : MultiplyOperatorsWithMultiplicativeIdentity<T>, IAdditionOperators<T, T, T>;

Uses: Concepts flatten

A naive method is to flatten all concepts at compile time. So that

public static T Bar<T>(T x) where T : Foo<T>
{
    return (x + x) * x;
}

gets lowered to

public static T Bar<T>(T x) where T : IMultiplyOperators<T, T, T>, IMultiplicativeIdentity<T, T>, IAdditionOperators<T, T, T>
{
    return (x + x) * x;
}

This allows a more structural way of constraints instead of the nominal way we have today. And also, this allows us to replacing existing sets of generic constraints with concepts, without any breaking change.

[huoyaoyuan]

So it's an alias for type constraint combinations. The name "concept" may imply something more in different context.

There hasn't been a practice for exposing alias in compiled assembly in C#. The using and global using aliases are still distributed by source code.

[jnm2]

I agree that the word "concept" is too broad to mean "set of constraints."

[TahirAhmadov]

Can this be expanded in the future, though?
Say, as a method parameter type; similar mechanism to unions; and it gets lowered to "cast and invoke" as needed.

[dersia]

Cloudn't we just use using for this?

using Foo<T> = MultiplyOperatorsWithMultiplicativeIdentity<T> & IAdditionOperators<T, T, T>;

it's already a known syntax for aliasing and it would work in the future for other scenarios.

the pnlything that might be confusing, to newcomers this could look like the definition for unions.

[KennethHoff]

Is there a reason for this to be in the IL at all? It's effectively just an alias

[TahirAhmadov]

I think it's useful to share them between projects. Like reference a nugget and get these aliases