On Thursday, 15 July 2021 at 11:02:17 UTC, wjoe wrote:
On Thursday, 15 July 2021 at 04:07:49 UTC, Tejas wrote:
Your code
```d
auto x = i[1]++;
```
Expands to:
```d
auto x = (auto e = i[1]/*notice opIndex*/, ++i[1]/* notice
opIndexUnary*/, return e;);
```
This doesn't happen with pre increment. No compiler
shenanigans.
Interesting to see it spelt out like this (your remarks are
very enlightening) so I just went one step further and rewrote
this line like so:
```D
i[1] = 3;
auto x = (){auto e = i[1]; ++i[1]; return e;}();
assert (i[1] == 4 && x == 3);
```
This just works. But I don't think this is what happens. What I
think happens is that the compiler rewrites ```i[1]++`` to
something like this:
```D
i.opIndex(1).opUnary!"++"();
```
plus all the other shenanigans.
Oh yes, that is what happens. I was trying to be a little concise.
You are correct, this is what the code will look in the gory
details (I believe) :
```d
auto x = (auto e = i.opIndex(1), i.opIndexUnary("++")(1)/*this
may or may not expand to what you wrote, not sure what the
compiler does, although what you say does sound like the obvious
thing to do*/, return e);
```
I did indeed override opIndex() but since i need to apply a bit
mask and do some shifting I can't return anything by ref.
As I mentioned, maybe the bit manipulation library could
help(although they don't seem to be overloading the operators in
the first place, thus sidestepping the problem you encountered).
