Re: A function that cannot be called?

[marciant@earthlink.net]

On Thursday, October 18, 2018 at 8:14:32 AM UTC-4, G.B. wrote:
> There is a type declaration, I rememberd, in Ada, that
> does not allow any object of the type to be declared.
> I think the type should be along the lines below. Is
> this correct?
> 
> Then, a function that nominally returns objects of
> this type should be impossible to call. Is this right,
> too?
> 
> generic
>      type T(<>) is limited private;  -- gen. arg. type
> 
> package What is
> 
>      type Void (<>) is private;
> 
>      function Impossible (X : T) return Void;
> 
> private
> 
>      package Inner is
>          type Void (<>) is private;
>      private
>          type Void is  record
>              null;
>          end record;
>      end Inner;
> 
>      type Void is new Inner.Void;
> 
> end What;
> 
> (If current Ada could still pass by reference in both call
> direction and return direction, then I'd have added *limited*
> to the Voids' declarations. Without it, a body of Impossible
> is closer to becoming possible by using Convention => Ada
> together with an 'Address clause on a Result object. I think.)

Before Ada 95 or Ada 2005 it would have been a package
spec that had the following (with P1,P2,etc. being valid types): 

type Not_Objects_Just_for_Parameters is limited private;
function Return_A_Corresponding_Value(p1:t1;p2:t2;etc...)
  return Not_Objects_Just_for_Parameters;
procedrure Force_Call_Of_Function_1
          (Function_Call:Not_Objects_Just_for_Parameters;
           Other_Param3:p3;etc...);
procedrure Force_Call_Of_Function_2
          (Function_Call:Not_Objects_Just_for_Parameters;
           Other_Param4:p4;etc...);

I miss that way of forcing/ensuring new execution of some
code as a prerequisite of use of a subprogram. ;-(
Being able to hang on to the result of such a function
by using renames wrecks this usage.