Strange copying of a constant array of structures

[Steven Schveighoffer]

On Friday, 14 June 2024 at 08:03:47 UTC, Vindex wrote:
> Last night I encountered some strange behavior of the dup 
> function.
>
> ```
> import std.stdio;
>
> struct S {
>     int x;
>     int y;
>     int[] arr;
>     this(ref return scope const S rhs) {
>         writeln("copy ctor");
>         this.x = rhs.x;
>         this.y = rhs.y;
>         this.arr = rhs.arr.dup;
>     }
> }
>
> void main() {
>     const S[] array = [S(0, 0), S(1, 2)];
>     S[] copy = array.dup;  // error
> }
> ```
>
> We have an issue:
> ```
> Error: none of the overloads of template `object.dup` are 
> callable using argument types `!()(const(S[]))`
> ```
>
> But(!) if we remove the dynamic array field from the structure, 
> everything works.

I think the fact that `dup` is not using the copy ctor is a bug.

This was recently reported: 
https://issues.dlang.org/show_bug.cgi?id=24432

>
>
> I decided to get around the problem by writing my own function 
> to copy arrays:
>
> ```
> T[] copyArray(T)(const T[] arr) {
>     T[] copy = new T[arr.length];
>     for (size_t i = 0; i < arr.length; i++) {
>         copy[i] = arr[i];  // error
>     }
>     return copy;
> }
>
> void main() {
>     const S[] array = [S(0, 0), S(1, 2)];
>     S[] copy = copyArray(array);
> }
> ```
>
> Nice, simple function, but it doesn't compile on the assignment 
> line:
> ```
> Error: cannot implicitly convert expression `arr[i]` of type 
> `const(S)` to `S`
> ```
> (The feature is the same: if we remove the dynamic array field 
> from the structure, everything works.)

Yes, you are *assigning*, not *constructing*. You could 
potentially make it work using `core.lifetime.emplace`, which 
treats it like a construction.

In order to make this work, you need an appropriate `opAssign`.

> An additional variable solution worked:
>
> ```
> T[] copyArray(T)(const T[] arr) {
>     T[] copy = new T[arr.length];
>     for (size_t i = 0; i < arr.length; i++) {
>         T elem = arr[i];  // copy ctor is called
>         copy[i] = elem;  // copy ctor isn't called!
>     }
>     return copy;
> }
> ```
>
> I feel that I do not understand something, please explain what 
> is the problem of constant structures with reference fields?

So this is *constructing* `elem` as a non-const T. This calls the 
copy constructor.

The assignment just does a bit-copy of the first value into the 
second, but since both are not const, it works fine.

Construction happens on *initialization*, that is, declaring a 
variable and specifying an initial value.

Assignment happens when assigning to an *existing* variable.

What is the difference? In construction, the compiler knows that 
the values in the type have never been assigned a value before. 
So it allows certain things (e.g. assigning to an immutable 
value).

-Steve