• Dave P. (38/43) Oct 19 2021 However, the following program compiles and the resulting
• jfondren (16/28) Oct 19 2021 It says `value v` and `struct S`, but you go on to cast a struct

Dave P. <dave287091 gmail.com> writes:

I am confused on how casting structs works. According to point 9 
of https://dlang.org/spec/expression.html#CastExpression:

 Casting a value v to a struct S, when value is not a struct of 
 the same type, is equivalent to:

 ```d
 S(v)
 ```

However, the following program compiles and the resulting 
execution indicates the bits are just being reinterpreted.

```d
// casttest.d
import std;

struct Foo {
     int i;
     float x;
}

struct Bar {
     float i;
     int x;
}

void main(){
     Foo foo = Foo(10, 1.035);
     writeln(foo);
     auto b = cast(Bar)foo;
     writeln(b);
     auto c = cast(Bar)b;
     writeln(c);
     // auto d = Bar(foo); // casttest.d(21): Error: cannot 
implicitly convert expression `foo` of type `Foo` to `float`
     // auto e = Bar(b); // casttest.d(22): Error: cannot 
implicitly convert expression `b` of type `Bar` to `float`
}
```

Execution results in:

```
Foo(10, 1.035)
Bar(1.4013e-44, 1065646817)
Bar(1.4013e-44, 1065646817)
```

Additionally, the commented out lines indicate that what the spec 
claims the cast is equivalent to wouldn’t even work.

Is this a bug in my understanding? Bug in the spec? Bug in the 
compiler?

jfondren <julian.fondren gmail.com> writes:

On Wednesday, 20 October 2021 at 04:14:37 UTC, Dave P. wrote:
 I am confused on how casting structs works. According to point 
 9 of https://dlang.org/spec/expression.html#CastExpression:

 Casting a value v to a struct S, when value is not a struct of 
 the same type, is equivalent to:

 ```d
 S(v)
 ```


It says `value v` and `struct S`, but you go on to cast a struct 
into another struct.

Point 9 is exhibited by

```d
struct Foo {
     int i;
}

unittest {
     int n = 2;
     Foo f = cast(Foo) n;
}
```

 However, the following program compiles and the resulting 
 execution indicates the bits are just being reinterpreted.

...
 Is this a bug in my understanding? Bug in the spec? Bug in the 
 compiler?

It looks at least like a gap in the spec. Adding "or a struct to 
another struct" to point six would fit the observed behavior.