scoped classes

[ag0aep6g via Digitalmars-d-learn]

On 04/27/2017 05:47 PM, Alex wrote:
> void main()
> {
>     S[] arr;
>     S s = S(42);
>     arr = [s]; // this doesn't work :(
> }
>
> struct S
> {
>     @disable this();
>     @disable this(this);
>     this(size_t dummy){}
> }

1) Construct the S instance directly in the array literal:

----
arr = [S(42]);
----

But I guess that's besides the point. So ...

2) Use std.algorithm.mutation.move [1]:

----
import std.algorithm.mutation: move;
S s = S(42);
arr = [move(s)];
----

`move` makes a "destructive copy" here; i.e, it resets `s` to `S.init`.

You probably want to append to that array at some point. That's going to 
be more tricky, because appending potentially involves copying the whole 
array.

This might work:

----
import std.algorithm.mutation: moveEmplace;
import std.array: uninitializedArray;

/* Make a new, larger array: */
S[] new_arr = uninitializedArray!(S[])(arr.length + 1);

/* Copy existing elements; destroy old array: */
foreach (size_t i; 0 .. arr.length) moveEmplace(arr[i], new_arr[i]);

/* Copy new element; destroy s: */
moveEmplace(s, new_arr[$ - 1]);

/* Replace old array with new one: */
arr = new_arr;
----

Notes:

* `moveEmplace` and `uninitializedArray` are completely unsafe. You must 
ensure safety yourself.

* I'm not entirely sure that the code is completely correct. It might be 
invalid and break some language rule.

* I'm pretty sure that the code is going to be invalid when you're 
dealing with const/immutable data.

* The code destroys the old array. References to it (slices of it, 
pointers into it) will show .init values.

* Maybe one can make use of `.capacity` somehow. As it is, the code 
makes a copy of the whole array every time.

* If this "moveAppend" functionality can be done in a valid manner, it 
might be a worthwhile addition to the "move" function family.



[1] http://dlang.org/phobos/std_algorithm_mutation.html#.move