ConstTypeArgs.Core 1.0.0

Builds on type of the ConstTypeArgs.Core library to provide const type arguments that allow you to use type parameters to pass int values to generics at compile-time. This provides an analog to type specialization in C++, and can be used for scenarios such as: * Static configuration, * Eliminating unnecessary instance constructors, * "Passing" values to type initializers, * And more. Built-in const type arguments cover -1 to -15, 0 to 15, powers of 2 up to 65536, and more. Here's a simple demonstration showing how to define and use const type arguments and domain-specific type arguments: using ConstTypeArgs.Ints; // Const type arguments: public readonly struct _8 : K_Int<_8> { public static int Value => 8; } public readonly struct _32 : K_Int<_32> { public static int Value => 32; } public abstract class DefaultSize : Int<_32> { } // Usage: public class Foo<TSize> where TSize : K_Int { public static readonly int[] FooArray = new int[TSize.Value]; static Foo() { Console.WriteLine($"Array size is {FooArray.Length}"); } } // Elsewhere var foo = new Foo<_8>(); // Outputs "Array size is 8" foo = new Foo<DefaultSize>(); // Outputs "Array size is 32"

Builds on types of the ConstTypeArgs.Core library to provide const type arguments that allow you to use type parameters to pass nuint (UIntPtr) values to generics at compile-time. This provides an analog to type specialization in C++, and can be used for scenarios such as: * Static configuration, * Eliminating unnecessary instance constructors, * "Passing" values to type initializers, * And more. Here's a simple demonstration: using ConstTypeArgs.Nuints; public class Foo<TSize> where TSize : K_Nuint { public static readonly int[] FooArray = new int[TSize.Value]; static Foo() { Console.WriteLine($"Integer array size is {FooArray.Length}"); } } // Elsewhere var foo = new Foo<_3>(); // Outputs "Integer array size is 3" foo = new Foo<_16>(); // Outputs "Integer array size is 16" The following shows how a new nuint const type argument could be defined. public readonly struct _32 : K_Nuint<_32> { public static nuint Value => 32; } You can also create new domain-specific nuint const type arguments like so: public sealed class DefaultInitialCollectionSize : K_Nuint<_32>;

Builds on type of the ConstTypeArgs.Core library to provide const type arguments that allow you to use type parameters to pass long values to generics at compile-time. This provides an analog to type specialization in C++, and can be used for scenarios such as: * Static configuration, * Eliminating unnecessary instance constructors, * "Passing" values to type initializers, * And more. Built-in const type arguments cover -1 to -15, 0 to 15, powers of 2 up to 65536, and more. Here's a simple demonstration showing how to define and use const type arguments and domain-specific type arguments: using ConstTypeArgs.Longs; // Const type arguments: public readonly struct _8 : K_Long<_8> { public static long Value => 8; } public readonly struct _64_000 : K_Long<_64_000> { public static long Value => 64000; } public abstract class DefaultSize : Long<_64_000> { } // Usage: public class Foo<TSize> where TSize : K_Long { public static readonly long LargeArraySize = TSize.Value; // Code to initialize large arrays. static Foo() { Console.WriteLine($"Large array size is {LargeArraySize.Length}"); } } // Elsewhere var foo = new Foo<_8>(); // Outputs "Large array size is 8" foo = new Foo<DefaultSize>(); // Outputs "Large array size is 32"

Builds on type of the ConstTypeArgs.Core library to provide const type arguments that allow you to use type parameters to pass ulong values to generics at compile-time. This provides an analog to type specialization in C++, and can be used for scenarios such as: * Static configuration, * Eliminating unnecessary instance constructors, * "Passing" values to type initializers, * And more. Built-in const type arguments cover 0 to 15, powers of 2 up to 65536, and more. Here's a simple demonstration showing how to define and use const type arguments and domain-specific type arguments: using ConstTypeArgs.Ulongs; // Const type arguments: public readonly struct _8 : K_Ulong<_8> { public static ulong Value => 8; } public readonly struct _32 : K_Ulong<_32> { public static ulong Value => 32; } public abstract class DefaultSize : Ulong<_32> { } // Usage: public class Foo<TSize> where TSize : K_Ulong { public static readonly int[] FooArray = new int[TSize.Value]; static Foo() { Console.WriteLine($"Array size is {FooArray.Length}"); } } // Elsewhere var foo = new Foo<_8>(); // Outputs "Array size is 8" foo = new Foo<DefaultSize>(); // Outputs "Array size is 32"

Builds on types of the ConstTypeArgs.Core library to provide const type arguments that allow you to use type parameters to pass float values to generics at compile-time. This provides an analog to type specialization in C++, and can be used for scenarios such as: * Static configuration, * Eliminating unnecessary instance constructors, * "Passing" values to type initializers, * And more. Built-in const type arguments include Default, MinValue, MaxValue, E, Epsilon, Pi, Phi, Tau, NaN, PositiveInfinity, NegativeInfinity, and _0. Here's a simple demonstration showing how to define and use const type arguments and domain-specific type arguments: using ConstTypeArgs.Floats; // Const type arguments: public readonly struct _1_2345 : K_Float<_1_2345> { public static float Value = 1.2345; } public readonly struct _6_789 : K_Float<_6_789> { public static float Value = 6.789; } public abstract class DefaultValue : Float<_1_2345> { } // Usage: public static class Foo<TFloat> where TFloat : K_Float { private static readonly float Value = TFloat.Value; } // Elsewhere: Console.WriteLine($"Foo's value if default: {Foo<DefaultValue>."); Console.WriteLine($"Foo's non-default value: {Foo<_6_789>.Value}.");