Below is the reduced code that replicates my problem.
I'm trying to remember a value (of some type) that can be used at
run time (assigned to a variable). "Remembering" must be done at
compile time because it's a part of UDA.
```d
// I can't get rid of this struct because it contains a lot of
information and needed to perform business logic (but I can
change the content):
struct S(T)
{
T value;
// I prefer to keep `const` here
void f(ref T v) const { v = value; }
}
// I can't get rid of this function as this is public API and
actually used in UDA:
auto create(VALUE)(VALUE value)
{
return S!VALUE(value);
}
// Case with `string` work perfectly
{
enum o = create("abc");
string v;
o.f(v);
v.writeln;
}
// But `string[]` doesn't work (complain is for `S.f`):
// Error: cannot implicitly convert expression `this.value` of
type `const(string[])` to `string[]`
{
enum o = create(["abc"]);
string[] v;
o.f(v);
v.writeln;
}
```
If I change S.f to either `void f(ref T v) const { v = cast(T)
value; }` or `void f(ref T v) const { v = value.to!T; }` then
everything works. Is this a correct/safe way to go since I'm
copying `const string[]` to `string[]`?
