Re: Announce: Grace project site operational

[Dmitry A. Kazakov <mailbox@dmitry-kazakov.de>]

On Wed, 22 May 2002 12:31:05 -0400, Hyman Rosen <hyrosen@mail.com>
wrote:

>Dmitry A. Kazakov wrote:
>> It is not much better than: #define private public.
>
>I don't understand what this means. If you do this inconsistently,
>you are violating the rules of the language, and the result is
>undefined behavior. I cannot imagine how this is related to templates.

The problem is that you cannot gain very much by checking the program
against specifications alone. That is not enough, you need the body =
implementation. You might argue that it is no matter because to change
the implementation one need to recompile the whole system. But I doubt
that this another disadvantage of generics is an excuse.

> > So far the result
>> remains a valid programs it is fine! That actual has or has not plus
>> will be checked in C++ only after substitution. One need body to check
>> that! Consider that somebody has instantiated your template, but did
>> not use the bodies where + is used. No error, though the contract is
>> broken. Well, after 10 years or so, somebody would try to use that
>> bodies and run at misterious errors in the code which is supposed to
>> be safe.
>
>Once they try to use the body, the code will fail to compile.
>This will not be unsafe in the sense of causing the program
>to behave improperly, since it will not build at all.

Yes, but you should agree that for a large project that could be
unacceptable.

>Therefore, it is difficult, and likely
>useless, for a template writer to specify some definite origin
>for the operator. The only purpose will be to limit the utility
>of the template.

I agree with you but for other reason. If you can specifiy the formal
type as 

    type Thing is new Field with private;

then probably you need no generic at all. Because if declaring objects
of Thing and operations on Thing is all what you need, then
Field'Class would perfectly do the work. So my original point, if a
language has a good type system, then there is little need in
generics. Class-wide programming might supersede programming with
generics.

I strongly believe that as ADT will progress, generics will become
sort of GOTOs = use only if you really need it, once in your life.

>Nevertheless, some people (like you!) want this kind of checking
>anyway, and it is possible to code the checks in C++, through a
>process called "concept checking". This uses template metaprogramming
>to cause templates to fail to compile when instantiated with types
>that fail the concept check.

That's good, but not enough, because the semantic of the operator +
might be different. For instance, not all floating-point algorithms
are working on integers. So your program might pass the compiler and
yet be corrupt. Templates violate LSP too readily.

---
Regards,
Dmitry Kazakov
www.dmitry-kazakov.de