Re: Redispatching

[Georg Bauhaus <rm-host.bauhaus@maps.futureapps.de>]

On 18/04/14 22:51, Dmitry A. Kazakov wrote:

> Consider this set of declarations:
>
>     type T is ...;
>     procedure Bar (X : T);
>
>     type S is new T ...;
>     procedure Foo (X : S);
>
> Now the following is illegal:
>
>     procedure Bar (X : T) is
>     begin
>        X.Foo;  -- Compile error
>     end Bar;
>
> X in Bar is of the type T and of no other type.
>
> You can convert X using so-called "view-conversion" to an object of another
> type, e.g. S or T'Class. This conversion is a type conversion. Yes, it has
> certain properties when X is tagged (and thus by-reference), such as
> reusing the old object for the new one. These properties are irrelevant to
> the type semantics though. You get an object of a different type.

Actually, in Ada, you will predictably get the object that is passed
for X, which "is" of its type. (As usual, the discussion hinges on
the meaning of "is".) This provides the programmer with more semantic
possibilities:

    procedure Bar (X : T) is
    begin
       S(T'Class(X)).Foo;  -- No compile error
    end Bar;

This type conversion (downwards) is legal, and it permits deferring any type
checking to run-time, should programmers have reason to do so. If you think
this is improper design, why not outline an algorithm that transfers any
such program into one that demonstrably dispenses with downward conversions.

> If Ada supported classes of by-copy types, then conversion to S or T'Class
> would produce a new object. But the type semantics would remain same.

In view of the above example, absent an isomorphic program transformation
as requested, by-copy types will require changing the semantics of Ada.