Allow Altering of a Member in a Discriminated Union

[MoxyFoxy]

Is your feature request related to a problem? Please describe.
The current syntax of trying to alter a field which is a member of a discriminated union is quite frustrating and extremely unintuitive. When attempting to access a member of a discriminated union, you'd expect alterations to it to stay since you're accessing a field from a struct. However, it actually copies it instead of referencing it.

Example from my code:
call.variant.(Call).args = temp_node_storage[:];
You'd expect that altering call.variant would alter the variant in call. However, the changes to not stay. This is extremely unintuitive.

Example of how to modify the field (from Tetralux):

#partial switch x in &call.variant {
case Call:
    x.args = temp_node_storage[:];
}

I would have never thought of this at all.

Describe the solution you'd like
I would like to be able to modify fields that are a member of a discriminated union just like I would any other field. There shouldn't be any distinction between modifying foo.bar and foo.baz.(WhateverGoesAfterBaz).WhateverGoesAfterBaz2ElectricBoogaloo (please excuse my poor sense of humor).

Additional context
Here's the full chunk of code and its output:

Code:

call.variant.(Call).args = temp_node_storage[:];
fmt.print("Returning call: `");
fmt.print(call.name);
fmt.print("` with arguments: ");
fmt.println(call.variant.(Call).args);

fmt.print("Temp node storage for `");
fmt.print(call.name);
fmt.print("`: ");
fmt.println(temp_node_storage[:]);

Example (wrong) output:

Returning call: `+` with arguments: []
Temp node storage for `+`: [AST_Node{name = x, variant = VariableCall{}}, AST_Node{name = /, variant = Call{args = []}}]```

[Tetralux]

i.e:

x.(S).f = 4;

Should act similarly to:

v := &x.(S);
v.f = 4; // modifies 'x'

[gingerBill]

The switch is the approach I want to encourage. Sometimes the syntax and semantics are weird on purpose, like in this case.

[gingerBill]

(&x.(S)).f = 4;

This will work, and is much clearer what is going on too. Even if it's "ugly".

[JoshuaManton]

This reminds me of being able to assign to array elements as in:

arr[i] = 123;

Could the same mechanism/design not apply? (&x.(S)).f = 4; is fine but it seems to me there is precedent for assigning to something that "looks like" an rvalue.