On Tuesday, 14 December 2021 at 16:21:03 UTC, Steven
Schveighoffer wrote:
On 12/14/21 11:19 AM, Steven Schveighoffer wrote:
Er... scratch that, this isn't construction, it should use
opAssign. Again, probably because memcpy+postblit is used by
the runtime.
If not reported, it should be.
On 12/14/21 11:19 AM, Steven Schveighoffer wrote:
Er... scratch that, this isn't construction, it should use opAssign.
Again, probably because memcpy+postblit is used by the runtime.
If not reported, it should be.
Simple proof that it is a bug:
```d
immutable (ComplexStruct)[] arr;
On 12/14/21 11:14 AM, Steven Schveighoffer wrote:
On 12/14/21 10:53 AM, Stanislav Blinov wrote:
Now, since we have copy ctors, slice assignment should, ostensibly,
attempt to copy-assign elements (i.e. absent opAssign, try the copy
ctor first).
I agree slice-assign should work here with a
On 12/14/21 10:53 AM, Stanislav Blinov wrote:
Now, since we have copy ctors, slice assignment should, ostensibly,
attempt to copy-assign elements (i.e. absent opAssign, try the copy ctor
first).
I agree slice-assign should work here with a copy ctor. What I think is
happening is that it's
On Tuesday, 14 December 2021 at 15:28:30 UTC, Steven
Schveighoffer wrote:
All the other problems you are having are deriving from this
problem.
Not exactly. One of the problems seems to be a genuine bug:
```d
struct S
{
int[] x;
// doesn't even participate here, neither would
On 12/14/21 3:44 AM, rumbu wrote:
I am trying to understand why in this two different cases (Simple and
Complex), the compiler behaviour is different.
```d
struct SimpleStruct { int x;}
struct ComplexStruct { int[] x; }
void main()
{
SimpleStruct[] buf1;
immutable(SimpleStruct)[]
On Tuesday, 14 December 2021 at 12:13:23 UTC, Stanislav Blinov
wrote:
Because is(typeof(immutable(ComplexStruct).x) ==
immutable(int[])). Can't bind an array of immutable to array of
mutable. This would require a deep copy, i.e. copy constructor.
This means that the only way to write a
On Tuesday, 14 December 2021 at 08:44:02 UTC, rumbu wrote:
I am trying to understand why in this two different cases
(Simple and Complex), the compiler behaviour is different.
```d
struct SimpleStruct { int x;}
struct ComplexStruct { int[] x; }
void main()
{
SimpleStruct[] buf1;
On Tuesday, 14 December 2021 at 08:44:02 UTC, rumbu wrote:
I am trying to understand why in this two different cases
(Simple and Complex), the compiler behaviour is different.
```d
struct SimpleStruct { int x;}
struct ComplexStruct { int[] x; }
void main()
{
SimpleStruct[] buf1;
I am trying to understand why in this two different cases (Simple
and Complex), the compiler behaviour is different.
```d
struct SimpleStruct { int x;}
struct ComplexStruct { int[] x; }
void main()
{
SimpleStruct[] buf1;
immutable(SimpleStruct)[] ibuf1;
buf1[0 .. 10] = ibuf1[0 ..
10 matches
Mail list logo
