Add extra suffixes for the built-in data types.

[nathan130200]

The idea of the suggestion is to be able to add suffixes for primitive types.

We already have the suffixes of:

• 10 = int,
• 10U = uint,
• 10L = long,
• 10UL = ulong
• 10F = float
• 10D = double
• 10M = decimal

For the (u)short (s)byte and char types it could be something:

• 10H = short (or the suffix S)
• 10UH = ushort (or the US suffix)
• 10B = 10 in byte (causes an error if it is negative or exceeds 255)
• 10SB = 10 signed byte (causes an error if it is not in the range of -128 and 127)
• 32C = char? (ok, this one would be a little strange, I don't know if it's necessary that much)
• 0x0000N = nint/IntPtr (That one was weird too)
• 0x0000UN = nuint/UIntPtr (That one was weird too)

Or another alternative to implement something similar to C++ literal operators. So each developer could implement their suffixes, for example calling 10ms could translate to TimeSpan.FromMilliseconds(10).

In cases of ambiguity, the parameter type, variable type or return type can help the compiler understand which literal operator it will use correctly. So even if, for example, two structs define the literal operator "ms" (to correspond to milliseconds) based on the type, it will apply the correct operator.

[colejohnson66]

If this were to be done, I would reserve h for System.Half (like f for System.Single/float).

[nathan130200]

Any news on this?

We can consider also for (u)int8 and (u)int16

suffixes like:

• 10u8 or 10i8 for (s)byte.
• 10u16 and 10i16 for (u)short.
• alternatives for int32 such as 10u32 or 10i32
• alternatives for int64 such as 10u64 or 10i64
• (skip float, double and decimal because already exists)
• 10h for half types.

other types (not common for suffixes):

• maybe extra suffixes for u128 or i128 for System.(U)Int128 -> 1082071324729472394u128
• using g suffix for hexadecimal type guid: 0x......g -> System.Guid (of type N) compiler will transpile to Guid.ParseExact("", "N")

bad idea (maybe?)

• for n(u)int (System.[U]IntPtr) maybe 0x00000001234p using suffix p to indicate some pointer or handle. in this instead u suffix too for unsigned (UIntPtr) just use P in uppercase. since p/P is not hex char.

the suffix must be i (signed) or u (unsigned) (lowercase required), followed by num of bits 8, 16, 32, 64, 128.

[ds5678]

Smaller than 32 bits is mostly pointless because that's the size of a normal (not 64 bit) integer on the stack.

[nathan130200]

Yes but only for type check and prevent compiler errors when type does not match.

[wherewhere]

Hope to have long long for Int128 and can write Int128 number directly. BigInteger also.

[nathan130200]

maybe two L suffixes eg: var myInt128 = 1234LL; -> will replace to new Int128(...) same for ULL -> uint 128