Constants in Generic Types using static abstracts and interfaces

[dylanrafael05]

Heads Up

I have no idea what I am doing! I've been researching compilers and the nature of programming languages and have come across the idea of static abstract. With some toying around, I realized that values could be "smuggled" through generic parameters:

public interface ILiteral<T>
{
    static abstract T Value {get;}
}

public struct Example<T> where T : ILiteral<int>
{
    public readonly int value = T.Value;
}

This concept is quite intriguing, suggesting the possibility of C++ like template parameters (which are not types) in C#. For sake of argument, let's say that this could be worth codifying into C# as a language. I, in this case, would propose the following:

// The following would be added to the standard C# library
namespace System
{
    public interface ILiteralValue<T>
    {
        static abstract T Value {get;}
    }

    [AttributeUsage(AttributeTargets.Class |  AttributeTargets.Struct)] 
    public class LiteralTypeAttribute : Attribute
    {
        // . . . 
    }

}

// The following syntax would be valid (with "const" taking on a new contextual meaning here)
public class Vector<const int T>
{
    // . . . 
}

// Usages of the above parameter would be required to be constant.
// They would look like so:
Vector<1>
Vector<(int)Math.PI>
Vector<10-5>

// Like with normal generics, type inference can be made with these literal parameters.
// The way to do this inference would be identical to with standard parameters.

// The following types would be created whenever literals were passed as generic parameters
[CompilerGenerated, LiteralType]
public class <>_literal_int_1 : ILiteralValue<int>
{
    public static int Value => 1;
    private <>_literal_int_1() {}
}

// The source type would be essentially "lowered" to . . . 
public class Vector<T> where T : ILiteral<int> {}

// And usages as . . . 
Vector<1> => Vector<<>_literal_int_1>

// As a possible extension, two properties could be added to the `Type` class
// bool Type.IsLiteral => this.HasAttribute<LiteralType>()
// bool Type.LiteralValue => . . . idk how to impl this but its possible!

I'm just posting this out of intrigue, since this could pose interesting points or possibly just be interesting trivia, but I think it's of worth to note.

Any thoughts? Could this idea be extended to non-constant but literal expressions, or even expressions with dynamic evaluations using a new contextual use of the keyword dynamic as in Type<dynamic int T>? Could this even, in the extreme, be taken to allow functions as inputs, as in Type<delegate int T(int a)>?

[IS4Code]

Cool idea! A good first step would be to pick (or add) a proper standardized BCL interface to use for this to be a syntactic sugar to,

I don't think const or dynamic would be needed if the expression should be evaluated only once. For example, Class<static Math.Sqrt(2.0)> could easily produce this:

public class Generated : ILiteralValue<double>
{
    public static double Value { get; } = Math.Sqrt(2.0);
}

Here the value is computed only once but stays constant. But just in case a malicious programmer would want to change it, each type could simply cache the value itself:

public class Vector<T> where T : ILiteralValue<int>
{
    static readonly int actualT = T.Value;
}

This is the only way the type can ensure it's constant anyway.

[dylanrafael05]

Even the first on its own would serve to mitigate the issue of non-constant expressions, since the property would act as a wrapper for a readonly static field.

[Rekkonnect]

I'm in favor of templates, but generics are probably a bad idea to integrate this feature on. Don't get me wrong, the idea of dynamically creating a type denoting the literal passed onto the generic parameter is clever enough, but only gets you so far as to bypass the limitations posed by the infrastructure. The design looks scary at best, if you evaluate a rough sketch on how it would be integrated into the compiler.

That being said, Vector<N> sounds extremely useful, and is one of the reasons C++ has templates allowing from numeric literals to type arguments. C# designed generics to be specific to type arguments, and extending them into templates would either require a full rework (which sounds impossible enough) or a new construct that extends the domain generics apply to.

P.S. Possible duplicate of #1315?

[iam3yal]

@Rekkonnect It doesn't really relate to generic specialization but constant expressions.