AA and struct with const member

[Era Scarecrow]

On Monday, 27 December 2021 at 19:38:38 UTC, frame wrote:
> I feel stupid right now: One cannot assign a struct that 
> contains const member to AA?
>
> Error: cannot modify struct instance ... of type ... because it 
> contains `const` or `immutable` members
>
> This is considered a modification?
> ```d
> struct S
> {
>   const(int) a;
> }
>
> S[string] test;
> test["a"] = S(1);
> ```
>
> Whats the workaround for that?

const/immutable members are to be set/assigned instantiation. 
Most likely the problem is a bug and sounds like

a) the struct doesn't exist in the AA, so it creates it (with a 
default)
b) It tries to copy but contains a const and thus fails

Passing a pointer will do you no good, since structs are likely 
to be on the stack.

So let's try opAssign.

```d
   auto ref opAssign(S s) {
	this=s;
	return this;
   }
```

So we get
```
'cannot modify struct instance `this` of type `S` because it 
contains `const` or `immutable` members'.
```

Alright let's look at the members we can work with.
https://dlang.org/spec/hash-map.html

I don't see an 'add' but i do see a 'require' which will add 
something in. So we try that.

test.require("a", S(1));

```
Now we get:
Error: cannot modify struct instance `*p` of type `S` because it 
contains `const` or `immutable` members
test.d(??): Error: template instance `object.require!(string, S)` 
error instantiating
```

Hmmm it really doesn't like it. Finally we can fake it. Let's 
make a mirror struct without the const, for the purposes of 
adding it.

```d
struct S
{
   const(int) a;
}

struct S2
{
   int a;
}

S[string] test;
cast(S2[string])test = S2(1);
```
```
Error: `cast(S2[string])test` is not an lvalue and cannot be 
modified
```

Well that's not going to work. Let's make it a pointer and 
allocate it instead.

```d
S*[string] test;
test["a"] = new S(1);
```

  Success!

  So i summarize, either work with a pointer, or drop the const...