On 02/04/2011 10:29 PM, bearophile wrote:
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.
agreed
--------------------------
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
ditto
(implicit magic semantics is bad)
Denis
--
_________________
vita es estrany
spir.wikidot.com
