zygoloid wrote:
> I think there's a contradiction between what `define_aggregate` needs and
> that hypothetical `write_char_to_file` needs from the same language construct
> (which is currently called _plainly constant-evaluated expression_). If we
> say that we're not going to guarantee idempotency for any function that can
> have side effects during constant evaluation, then it seems that it just
> can't work. What do you think of this?
This behavior of `define_aggregate` seems strange to me -- I wonder if it's
trying to work around a "the same constant expression may be evaluated more
than once" concern, and if we instead guaranteed that doesn't happen, they
could avoid the complexity and instead say that it's an error to define a type
more than once.
Alternatively, something like:
```c++
consteval int f() {
if (!is_defined(^^S)) {
define_aggregate(^^S, {});
}
write_char_to_file("output.txt", 'a');
return 0;
}
```
seems like it could be workable. (Though that doesn't have the same "check the
definition is the same each time" property.)
Note that idempotency is *not* composable if you can observe whether the
idempotent action has already happened. For example:
```
struct A;
struct B;
consteval void f() {
if (!is_defined(^^A)) { define_aggregate(^^A, {}); }
else { define_aggregate(^^B, {}); }
}
```
Here, `f()` is not idempotent, even though all the pieces that it's constructed
from are. Evaluating a call to `f()` twice is not the same as evaluating a call
to it once.
https://github.com/llvm/llvm-project/pull/115168
_______________________________________________
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
