Re: Alternatives to C: ObjectPascal, Eiffel, Ada or Modula-3?

["Hibou57 (Yannick Duchêne)" <yannick_duchene@yahoo.fr>]

On 21 juil, 03:33, Cesar Rabak <csra...@yahoo.com.br> wrote:
> Does the subtyping in Ada complain if one makes an operation on two
> variables of type Length (here defined as 'type Length is new Float;')
> that there is not a compatible Length squared defined?

Yes it will, providing you've design things to go this way (compilers
are still automata, not form or artificial with capabilities to read
in your minde).

For your example, you may first define a private type, so that the
user of the type (except package implementation and child package)
cannot rely on its representation (a black box). You may define
initializers, which would be required, as the user would not be able
to initialize any value otherise. Ex. “ function To_Length (Value :
Natural) return Length_Type ” or “ procedure Set (Length : in out
Length_Type; Value : Natural); ”. You may also have a “ type
Length_Squared_Type is private; ”, private as well and a function “
function Length_Squared (Left, Right : Length_Type) return
Length_Squared_Type; ”. As you see, you can have a fully secured set
of specifications : the user can do only what is defined, and nothing
else. So it is easy to enforce Length_Type * Length_Type to be of type
Length_Squared_Type. Beceause the user cannot do a direct Length_Type
* Length_Type and must use the function you provide in this purpose.

Note : as Length_Type and Length_Squared_Type would probably be
defined in the same package specification, then Length_Squared_Type
could not derived from Length_Type (language rules), and and if you
want to use the same representation for both they could just both
derives from a base representation type which could not exist in the
public speficiation of the package, and then a little convertion will
be needed in the implementation. However, it would probably be nice to
have a wider type for Length_Squared_Type and to not have the same
representation (unless the Length_Type is designed so that there is
never an overflow when computing a Length_Squared_Type).

I apologize for details, as I'm not sure you know Ada well (it seems
this thread is broadcasted in multiple comp.lang.* at the same time).
But even with your Eiffel skills, I think it is possible to understand
the most important aspects.