Re: Overring function and its returned type

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

Le Fri, 09 Nov 2012 20:57:21 +0100, <sbelmont700@gmail.com> a écrit:

> More generally, you are talking about 'covariant return types', which is  
> a feature only a handful of languages support (notably C++).
May be (I feel to remember this, while unsure).

>  IMHO, i don't really see the need for it; a type is either a child (and  
> matches the parent, as in P3) or it doesn't and it's not (as in P2).   
> The whole point is to use the abstract parent classwide type  
> exclusively, so I never saw the need to tinker around with the concrete  
> child types (i would be interested in a real life scenario in which you  
> would want this construct)

I won't post here the real thing, I'm only OK to post samples and  
snippets. You will have to trust me when I say it make sense (so much, I  
wrote things straight away, without suspecting it could be rejected).  
Still, to give you an idea, imagine this:


In `P3` spec, replace the definition of `F` with this one:


           overriding
           function F
             (E : T)
              return P1.R'Class
              with Post'Class =>
                 F'Result in R'Class;


Then, a sample use case would look like this:


        A : P3.T;
        B : P3.R'Class := P3.R'Class (A.F);


That looks weird, as much weird as writing something like this:


        type IST is new Integer range 1 .. 10;

        function F return Integer
           with Post =>
              F'Result in 1 .. 10;

        function F return Integer
        is begin
           return 1;
        end;

        D : IST := IST (F);


Reading the above, one may say “that's silly, if you know the returned  
type, just specify it in the declaration, and this would additionally  
avoid a cumbersome checked conversion at every call place”. That's exactly  
what I feel adding a postcondition to `F` just to state what the returned  
type is, and adding a conversion at the call place. My words may looks a  
too hard, but I would say I would expect Ada to not require to specify  
types via pre/post condition, but in signature instead.

I will also try to workaround with an overloading instead of an  
overriding, but I'm afraid of getting into a mess with this solution. Will  
choose which cause the less troubles, and although the  
postcondition+conversion solution looks like bloat, I believe that's still  
the safest. I will still try both to really get an idea…


-- 
“Syntactic sugar causes cancer of the semi-colons.” [1]
“Structured Programming supports the law of the excluded muddle.” [1]
[1]: Epigrams on Programming — Alan J. — P. Yale University