On Wednesday, 14 July 2021 at 14:39:03 UTC, vit wrote:
On Wednesday, 14 July 2021 at 13:16:49 UTC, Tejas wrote:
On Wednesday, 14 July 2021 at 13:09:56 UTC, vit wrote:
On Wednesday, 14 July 2021 at 12:49:58 UTC, Tejas wrote:
[...]
From doc: https://dlang.org/spec/operatoroverloading.html
Postincrement e++ and Postdecrement e-- Operators
These are not directly overloadable, but instead are
rewritten in terms of the ++e and --e prefix operators:
Postfix Operator Rewrites
op rewrite
e-- (auto t = e, --e, t)
e++ (auto t = e, ++e, t)
Rewriting part doesn't work with operator overloading.
If the rewriting part doesn't work with overloading then why
aren't we allowed to explicitly overload
```post-increment/decrement``` operators?
How else will the OP solve their problem?
It must rewrite, otherwise it's impossible (I think).
This work:
```d
import std.stdio;
struct abc{
int[100] a;
ref int opIndex(int index)return{
return a[index];
}
}
void main (){
abc s;
s[0]++;
++s[0];
}
```
This does work for that example but I can't return by reference
because what I'm operating on is a part of an int.
Some context:
```D
struct part_int_t(ARGS...)
{
int _int;
mixin(generate_parts!ARGS);
}
alias handle_t = part_int_t!("isAllocated", 1, "gen", 8, "index",
23);
handle_t handle;
static assert (is(handle.typeof_isAllocated): bool));
static assert (is(handle.typeof_gen): ubyte));
static assert (is(handle.typeof_index): uint));
handle[2] = true;
handle.gen = 1;
handle.index = 1234;
assert (handle.isAllocated);
assert (handle.gen = 1);
assert (handle[0] = 1234);
handle++;
assert (handle.index == 1235);
handle.gen++;
assert (handle.gen == 2);
handle.reset();
assert (!handle.isAllocated);
assert (handle.gen = 3);
assert (handle.index = 0);
```
generate_parts!ARGS produces bit masks, getters, setters,
opIndex/OpAssign/Unary, etc. and it's impossible to return bits
0-26 of _int by ref.
