On 12/08/2021 9:36 PM, Learner wrote:
> It seems that there is no easy way to transition from a postblit to a copy constructor, no?

struct Foo {
	this(ref Foo other) {
		foreach(i, v; other.tupleof)
			this.tupleof[i] = v;
	}

	@disable this(this);
}

12.08.2021 12:36, Learner пишет:

>  > It seems that there is no easy way to transition from a postblit to a
> copy constructor, no?
> 
> 
> 

You just need both const and mutable copy ctors to replace inout one:
```D
struct A {
    int[] data;
    this(ref return scope A rhs) { data = rhs.data.dup; }
    this(ref return scope const A rhs) const { data = rhs.data.dup; }
}
```

the mutable copy ctor accepts mutable data and the const copy ctor accepts const and immutable data

12.08.2021 14:07, drug пишет:
> 12.08.2021 12:36, Learner пишет:
> 
>>  > It seems that there is no easy way to transition from a postblit to a
>> copy constructor, no?
>>
>>
>>
> 
> You just need both const and mutable copy ctors to replace inout one:
> ```D
> struct A {
>      int[] data;
>      this(ref return scope A rhs) { data = rhs.data.dup; }
>      this(ref return scope const A rhs) const { data = rhs.data.dup; }
> }
> ```
> 
> the mutable copy ctor accepts mutable data and the const copy ctor accepts const and immutable data

but using inout ctor is easier:
```D
struct A {
    int[] data;
    this(ref return scope inout A rhs) /* no inout here */ { data = rhs.data.dup; }
}
```
The problem is that if you qualify the ctor itself then if you pass const/immutable rhs to it then the ctor is const/immutable too (like the args) and of course you cannot modify this, so the error.

To make a copy ctor you need to qualify copy ctor args as inout but the copy ctor itself shall be mutable and have no const,immutable or inout qualifier.

On Thursday, 12 August 2021 at 10:10:17 UTC, rikki cattermole wrote:
>
> On 12/08/2021 9:36 PM, Learner wrote:
>> It seems that there is no easy way to transition from a postblit to a copy constructor, no?
>
> struct Foo {
> 	this(ref Foo other) {
> 		foreach(i, v; other.tupleof)
> 			this.tupleof[i] = v;
> 	}
>
> 	@disable this(this);
> }

This results to:

    Generating an `inout` copy constructor for `struct A` failed, therefore instances of it are uncopyable

12.08.2021 14:32, Paul Backus пишет:
> 
> This is not true. Qualifying the ctor as `inout` works fine: https://run.dlang.io/is/Kpzp5M
> 
> The problem in this example is that `.dup` always returns a mutable array, even if the array being copied is `inout`. The solution is to cast the copy back to the original type:
> 
> ```d
> this(ref return scope inout A rhs) inout
> {
>      data = cast(typeof(rhs.data)) rhs.data.dup;
> }
> ```

Yes, it's not true. I forgot that ctors are special in contrast to regular methods and can modify the aggregate they belong to even if the ctor has const/immutable/inout qualifier.

On Thursday, 12 August 2021 at 11:07:24 UTC, drug wrote:
> 12.08.2021 12:36, Learner пишет:
>
>>  > It seems that there is no easy way to transition from a postblit to a
>> copy constructor, no?
>> 
>> 
>> 
>
> You just need both const and mutable copy ctors to replace inout one:
> ```D
> struct A {
>     int[] data;
>     this(ref return scope A rhs) { data = rhs.data.dup; }
>     this(ref return scope const A rhs) const { data = rhs.data.dup; }
> }
> ```
>
> the mutable copy ctor accepts mutable data and the const copy ctor accepts const and immutable data

That still fails:

    Generating an `inout` copy constructor for `struct B` failed, therefore instances of it are uncopyable

Also if I remove the `const` body (can I assign data if the method is const?)

```D
struct A {
     int[] data;
     this(ref return scope A rhs) { data = rhs.data.dup; }
     this(ref return scope const A rhs) const {}
 }
Generating an `inout` copy constructor for `struct B` failed, therefore instances of it are uncopyable
```