On Tuesday, 7 October 2025 at 18:43:18 UTC, Vindex9 wrote:
What am I doing wrong?
I want a safe copy: `const string[][] -> string[][]`.
I think the approach should be, make a copy, then cast the copy,
recurse if it's a nested array.
What you are likely running into is that D automatically strips
the top-level const from a templated array.
That is:
```d
void foo(T)(T[] arr) {
pragma(msg, "in foo: ", typeof(arr)); // const(int)[]
}
void main()
{
const int[] arr;
pragma(msg, "in main: ", typeof(arr)); // const(int[])
foo(arr);
}
```
On top of that, you are adding `const` to the incoming type,
which can be problematic.
What I'd recommend is `inout` instead. This will unwrap to the
original type but still keep you from modifying the original
(like const).
My attempt:
```d
import std.traits;
inout(T)[] copyArray(T)(inout(T)[] arr) {
alias M = Unqual!T;
M[] result;
result.length = arr.length;
foreach(i, ref v; result) {
static if(is(T == U[], U)) // it's an array of arrays
v = cast(M)copyArray(arr[i]);
else
v = cast(M)arr[i];
}
return cast(typeof(return))result;
}
void main()
{
import std.stdio;
const string[][] arr = [["ABC", "DEF"], ["GHI", "JKL"]];
writeln(typeid(arr)); //
const(const(const(immutable(char)[])[])[])
const res = copyArray(arr); // note the const here, but still
typesafe without!
writeln(typeid(res)); //
const(const(const(immutable(char)[])[])[])
}
```
-Steve
