Re: A function that cannot be called?

[marciant@earthlink.net]

On Friday, October 19, 2018 at 4:25:53 PM UTC-4, Shark8 wrote:
<snip>
> > 
> > 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.
> 
> Isn't there a similar effect that can be had via
> 
>   Type Just_For_Parameters(<>) is limited private;
>   Function Get_Param return Just_For_Parameters;
>   --...
> PRIVATE
>   Type Stub_Record is null record;
>   Type Just_For_Parameters is not null access Stub_Record
>     with Size => 0;
>   --...

> Or am I misunderstanding what you're getting at? (Quite possible as I've never had occasion to use Size 0 "access"-types.)

I think you are but am not sure. I was focussing of the type from the point of view of an outside user of the package and the Size code that you presented would only affect use in the package body or child units.

The big problem that messed things up for me was now being able to something like this:

...

declare
  ob : Limitted_Private_Type renames Function_Call(...);
begin
  Proc1(ob);
  Proc2(ob);
  Proc3(ob);
  ...

all procs getting the same value/object (Function_Call is
evaluated only once.)

Oh! Maybe the bothersome thing now is that functions can no longer
return a limited result. (Not sure if that was a correct statement.)

Anyway, although I find that do not remember the exact details for now, but I do remember for sure that it once was possible to declare a visible type in a package spec that could not be used by an outside user as the type of a variable or constant and the only things that could be passed to any subprograms in the type's package were a call of a function from that package that returned that type (and maybe also deferred constants from that same package). Wow! It _has_ been a long ride.  :-)  :-/