Re: Anybody in US using ADA ? One silly idea..

[Hyman Rosen <hyrosen@mail.com>]

Dmitry A. Kazakov wrote:
> Of course no. Generics are unable to make String a subtype of
> Unbounded_String.

Ada generics, which labor under the restriction of needing to
specify things about the types on which they operate, not C++
templates, which work as long as used operations are supported.

> Any OO language does this.

Ada does not, C++ does not, I don't know for sure but I think
Eiffel does not. Smalltalk, maybe?

> Only if it is inherited.

Why? Since you're converting, what possible relevance is there
to requiring that the operation be present in both types?

> Ada does this.

Really? It does convert-in/convert-out of different types?
I've never seen that before. Can you show me sample code?

> Where you see a new concept? Circle and Ellise are two different
> types. So if you want make an Ellipse out of a Circle you must convert
> it. In Ada such conversions are called view-conversions.

As I said, no one else sees it this way. The normal OO view of
things is that if type B inherits from type A, then an object
of type B is also of type A. No conversion is required - the
object is already all of its base types.

> Now tell me why for SetAxis : Circle x R x R -> Circle it is not
> reasonable to throw an exception? Do not you see that NN vs. Float
> is same as Circle vs. Ellipse?

It is reasonable to do so if you must have your Circle put into
places that expect modifiable Ellipses. But I believe the general
feeling is that having subtypes which restrict the legality of
parent operations in this way is not good design. I suppose
Eiffel fans will disagree with this, since they seem to love the
idiom of inheriting operations but only allowing the new subtype
as an argument. Shudder. Java uses this style as well, with all
sorts of operations in subtypes throwing not-implemeneted exceptions.

> Sort of:
> template <double X> double sine () { return X; }
> // Works pretty well, as long X is close to zero

Actually, C++ template parameters can't be doubles, but why is
this any worse, or different, than

#include <iostream>
#include <cmath>

struct SineInterface
{ virtual double operator()(double) const = 0; };
struct SmallSine : SineInterface
{ double operator()(double x) const { return x; } };
struct RealSine : SineInterface
{ double operator()(double x) const { return std::sin(x); } };

void UsesSine(const SineInterface &si1, const SineInterface &si2)
{
     for (double x = 0; x < 1e-5; x += 1e-7)
         std::cout << x << ' ' << si1(x) << ' ' << si2(x) << '\n';
}

int main()
{
     UsesSine(SmallSine(), RealSine());
}