Re: Announce: Grace project site operational

[Hyman Rosen <hyrosen@mail.com>]

Dmitry A. Kazakov wrote:
> I did not claimed that C++ is untyped. I claimed that the formal
> template parameters are untyped in the sense that you cannot say:
> 
> template <class Thing that has +,
> 
> This requirement cannot be made a part of the contract. The contract
> is as simple as "any type that makes macro expansion a valid program".

Not macro expansion, but substantially correct otherwise.

> 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.

 > 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. Meanwhile,
there will have been ten years of perfectly good and valid use.

 > In Ada at least one can write:
> generic
>    type Thing is new Field with private; -- Field has "+"

In C++, an expression like a + b can find the meaning of it's
"+" operator in many ways. There can be free functions, member
functions, and conversions involved, and circumstances dictate
using various approaches. 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.

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.