Re: Ada The Best Language?

["Bertrand Augereau" <baugereau@ifrance.kom>]

> >
> >I don't see this type of code as a coding mistake, it is just a nonsense
way
> >of doing it. This can only be an intentional mistake and type safety is
> >there mainly for protecting you against non-intentional mistakes.
>
> What is the difference between "intentional" and "non-intentional"
> mistakes? Both result in blue-screen. It is nice to have Windows. We
> can always say, that it is Microsoft's fault when our programs crash
> (:-)). But what would be a blue-screen for a flight control system?

Oh, I never do that ;-)
You are right for critical applications. But I write videogames for a living
(PC & PS2) and you can't even rely on hardware and OS in this field, the
specs vary every day and the deadlines are insane, so the quality of your
code is not that important ;-)
I just wanted to say that *nobody* would write such code as a mistake. It
can only be intentional.
And I don't see whant "non-intentional" mistake you can do with this
enum->int conversion.

>
> >That's what forbidding implicit int->enum is for.
>
> Does the code above not contain an implicit int->enum conversion?
Nope. The enum is converted to an int, and then you can test its value if
you want. But I have to repeat it is totally illogical and nobody would
write such a thing.

>
> >I'm not sure a compiler has to take care of this error, though Ada
> >programmers might think otherwise.
>
> No doubts. BTW in Ada the counterpart of C++ switch statement shall
> cover all alternatives, so being translated into Ada
>
> switch (X)
> {
>    case BLUE  : break;
> }
>
> would be also illegal, because it is not clear what to do with RED and
> GREEN.

Most compilers issue a warning when you do not test every alternative of an
enum.
GCC does for instance.

>
> >It is often nice to have a enum->int conversion, especially when you can
map
> >your enum to some int you need.
> >
> >enum BOOL {
> >    FALSE = 0,
> >    TRUE = !0;
> >};
> >
> >Then if you need a enum->int mapping, you just have it for free by the
fact
> >enum are reprensented by int in the machine (as with Ada, I suppose). I
> >think you can do that in Ada if you need it with using clause.
>
> enum <-> int mapping is an implementation detail. There is no need to
> expose it. A program that relies on the fact that on some particular
> machine, occasionaly the representation of COLOR::BLUE and int::0 are
> same, is poorly designed. That C++ allows such things be implicit [in
> Ada you may achieve the same effect only by an explicit way], is a
> clear language design fault.

Agreed. Too much implicit is dangerous.
The major flaw of C++ is inheriting for C but I love the non-verbose syntax.