Jonathan M Davis:
> assert(0) has the advantage of being a normal assertion in non-release mode.
What is this useful for? To me this looks like a significant disadvantage. If I
want a HALT (to tell the compiler a point can't be reached, etc) I want it in
every kind of compilation of the program.
> It also makes it clear that that code path should _never_ be reached.
The replacement for assert(0) is meant to be more clear in its purpose compared
to assert(0). It may be named thisCantHappen(), or assertZero(), etc.
> The real question though is whether you can convince Walter (which I doubt,
> but I don't know).
This topic was already discussed, and I think the result of the discussion was
that this change of assert(false) is not worth it. But if asserts gets inproved
for other purposes, then this is a chance to work on improving assert(0) too.
> Still, making such a change _would_ contradict TDPL, which is supposed to be
> a major no-no at this point.<
I like TDPL, I respect Andrei and you, I agree that TDPL is a kind of reference
for D2, but please stop using TDPL as a The Bible in many of your posts. Not
even Andrei himself looks so religiously attached as you to the contents of
TDPL :-) A little flexibility is acceptable.
--------------------------
Adam Ruppe:
>Again, I think this makes sense too. assert(n) is saying, in principle,
>"ensure n is valid". Calling the invariant is part of ensuring it is valid.
>The only problem is a minor bug - it forgets to check for null before calling
>the invariant. That should, of course, be fixed, but the main behavior makes
>sense.<
Something like class_instance.invariant() is better because:
- It's explicit and readable. While you need to read the D manual to know that
assert(class_instance) tests the invariant too, and not just that
class_instance reference is not null. I remember other persons in D.learn not
knowning/suprised by that assert(class_instance) tests the invariant too.
- It removes a special case, and special cases kill languages. Struct instances
too allow an invariant, but they are not callable with assert(), see below. A
syntax like structlass_instance.invariant() is shared with the class one.
struct Foo {
int x;
invariant() { assert(x == 1); }
}
void main() {
Foo f;
assert(f);
}
DMD 2.051:
test.d(7): Error: expression f of type Foo does not have a boolean value
Bye,
bearophile
