Re: Community Input for the Maintenance and Revision of the Ada Programming Language

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

On 2017-08-11 09:57, Stefan.Lucks@uni-weimar.de wrote:

> If you want tuples, then it would be a lot more consistent to actually 
> propose the introduction of tuples (i.e., constant records) into the Ada 
> type system, e.g.,
> 
>     type May_Be_Integer(Valid: Boolean := True) is constant record
>       case Valid is
>      when True  => Value: Integer;
>      when False => null;
>       end case;
>     end record;

Hmm, isn't it simply a subtype:

    type May_Be_Integer (Valid: Boolean := True) is record
       case Valid is
          when True =>
             Value : Integer;
          when False =>
             null;
       end case;
    end record;

    subtype Surely_Integer is May_Be_Integer (True);

> Then you can the kind of functions you are requesting:
> 
>    function Calculate(A, B, C: Integer; D, E, F: Float) return Numeric;
>    -- returns either Integer or Float
[...]

This looks awful to me.

IMO the right approach, which I deployed on several occasions a tagged 
abstract type Numeric with descendants Integer_Number and Float_Number. 
Then "+" is multiple-dispatch emulated via cascaded dispatch:

    function "+" (A : Numeric; B : Numeric'Class) return Numeric'Class;

I don't see any relation to tuples.

However it has a relation to pure compile time subroutines. Because the 
above can be made statically checkable if the body could be split into 
pure and impure parts. The pure part would run at compile time if tags 
are statically known and fold the constants. The impure part will run if 
tags are unknown.

A similar case is dimensioned arithmetic which is closer to what you 
proposed when the dimension is packed in a discriminant rather than tag. 
Here again we want statically known discriminants eliminated and pure 
dimension checks in static cases.

-- 
Regards,
Dmitry A. Kazakov
http://www.dmitry-kazakov.de