Returning a reference to be manipulated

[IchorDev]

On Thursday, 13 April 2023 at 07:05:10 UTC, Chris Katko wrote:
> I'm trying to figure out how to return a reference to something 
> that may not be a reference type.
>
> ```D
> struct stats
> {
> float[string] data=0;
>
> float ref opIndex(string key)
>   {
>   return data[key]; // want a ref to a specific element
>   }
> }
>
> void test()
> {
> stats foo;
> auto x = foo.bar(); // returns some sort of reference
>        // data["tacos"] = 0
> x++;   // data["tacos"] = 1
> }
> ```
>
> Right now, I'm using pointers which resolves to:
>
> ```D
> // float* opIndex(string key){...} using pointer
> (*s["tacos"])++; // works with pointer, but is strange looking
>
> s["tacos"]++; // preferred syntax or something similar
> ```

I'm pretty sure you can't return `ref` to a value-type without it 
being a pointer, or a slice.
Unlike C++, D does not have `ref` variables (`&`). You can have 
value-type function parameters that are `ref` though.
But I feel that the easier solution for the example you gave 
would be to simply save the string used to index the float, 
rather than a reference to the float itself:

```d
import std.stdio: writeln;

struct Stats{
	float[string] data;
	
	float opIndex(string key){ return data[key]; }
	float opIndexAssign(float val, string key){ data[key] = val; 
return val; }
}

void main(){
	Stats foo;
	foo.data = ["tacos": 0];
	
	string ind = "tacos";
	float x = foo[ind];
	writeln(foo.data[ind]); //0
	x++;
	foo[ind] = x;
	writeln(foo.data[ind]); //1
}
```

Passing pointers around might be faster, but it's error-prone, 
and cumbersome for simple operators as you mentioned. However, 
you could always wrap your pointer in a struct with some 
necessary operator overloads:
```d
import std.stdio: writeln;

struct Float{
	float* data;
	
	float opUnary(string op: "++")(){ (*data)++; return *data; }
}

struct Stats{
	float[string] data;
	
	Float opIndex(string key){ return Float(key in data); }
}

void main(){
	Stats foo;
	foo.data = ["tacos": 0];
	
	Float x = foo["tacos"];
	writeln(foo.data["tacos"]); //0
	x++;
	writeln(foo.data["tacos"]); //1
}
```