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 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.)

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?

And why is the copy constructor only called once in the last example? Optimization?

On Friday, 14 June 2024 at 08:03:47 UTC, Vindex wrote:

const is transitive, not only S instances are but also their members.

Yes kind of optim. The compiler is allowed to use "move-semantics". Looks like it's what happens here (at first glance).

On Friday, 14 June 2024 at 08:03:47 UTC, Vindex wrote:

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
}

Error: none of the overloads of template `object.dup` are callable using argument types `!()(const(S[]))`

This is declaration of dup:

@property T[] dup(T)(const(T)[] a)
    if (is(const(T) : T))			
{
    import core.internal.array.duplication : _dup;
    return _dup!(const(T), T)(a);
}

constraint is(const(T) : T) ignore copy ctors. If S has property arr then const(S) is not implicitly convertable to mutable S.

Thanks!

So the array copy function implementation I showed is the best option?

I'm guessing it's the implicit opAssign method after all. The objects in the copy have already been created and initialized as T.init, so the copy constructor will not be called in any way.

On Friday, 14 June 2024 at 08:03:47 UTC, Vindex wrote:

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
}

Error: none of the overloads of template `object.dup` are callable using argument types `!()(const(S[]))`

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

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);
}

Error: cannot implicitly convert expression `arr[i]` of type `const(S)` to `S`

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.

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;
}

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

On Sunday, 16 June 2024 at 02:50:20 UTC, Steven Schveighoffer wrote:

Thank you! Especially for information about bug report.