On Saturday, 18 January 2025 at 07:31:40 UTC, Walter Bright wrote:

Oh, I really like this one. I've done that reinterpret cast quite a bit in my code.

-Steve

On Sunday, 19 January 2025 at 17:33:33 UTC, Paul Backus wrote:

Greater cost to compile time? Generally language features for commonly used patterns are pretty desirable.

On Saturday, 18 January 2025 at 07:31:40 UTC, Walter Bright wrote:

I would really like an actual DIP that I can read.

First: I think this type of cast should be @safe where conservatively possible. For example, I can’t think of any reason that casting from int to float in this way shouldn’t be @safe. For structs it’s more complicated, but you could try to check if both are POD, make sure the size is equal or less, etc.
Reinterpretation into bool is obviously always unsafe. ;)

Second: Is there a way to make this syntax also simplify these 2 similar patterns?

T[] foo = (cast(T*)malloc(T.sizeof * n))[0..n];

void[] foo = (cast(void*)&bar)[0..bar.sizeof];

Third: This is a long shot, but should we make it so that casting to a larger type is @safe by populating the remaining space with zeroes?

short foo = 10;
auto baz = cast(ref int)foo; //remaining 2 bytes filled with zeroes

It’s different from cast(long) in that the remaining bytes are always filled with zero, and it would always be the trailing bytes that are zero (on big endian systems, proper zero-extension prepends the zeroed bytes, not appends):
LE sign extension via cast(int):
0A 00 -> 0A 00 00 00
BE sign extension via cast(int):
00 0A -> 00 00 00 0A
LE cast(ref int):
0A 00 -> 0A 00 00 00
BE cast(ref int):
00 0A -> 00 0A 00 00
I can see this being useful for esoteric byte order manipulation. Moreso it’s actually useful for casting between struct types that have ‘inheritance’.

On Saturday, 18 January 2025 at 07:31:40 UTC, Walter Bright wrote:

This is how an unaware reader will parse the code:

ubyte val = 123;
auto x = cast(const long) val;     // x is const
auto y = cast(immutable long) val; // y is immutable
auto z = cast(shared long) val;    // z is shared

auto w = cast(ref long) val;       // w is ref

We now have local ref, and that makes this syntax a cognitive burden.

I know, that the type is const(long) and there is no ref(long) so this is technically correct, still, it will confuse users for a very little benefit.
Reinterpret cast is not a "commonly used patterns" it is a necessary evil, one can always make a local helper for it, if importing a module is a compile time issue.

Another example:

auto c0 = cast(scope long) val;   // Error
auto c1 = cast(ref long) val;     // Compiles, but confusing.

I am a sucker for syntax sugar, but this one, imho, sucks.

Juraj