Re: Access to function returning class-wide type

[Adam Beneschan <adam@irvine.com>]

On Aug 21, 3:13 am, Paweł 'Nivertius' Płazieński <nivert...@gmail.com>
wrote:
> Hello all.
>
> I'm new here, but I'll try to stick on.
>
> Let me start with a tricky problem:
>
> Consider following code:
>
> ----------------------------------------
>
> package A is
>         type Abstracted is abstract tagged null record;
>         function Proc (N : Natural) return Abstracted is abstract;
>
>         type The_Access_Type is access function (N : Natural) return
> Abstracted'Class;
>
> end A;
>
> -- package A body ommited;
>
> with A;
> package B is
>         type Derived is new A.Abstracted with null record;
>         function Proc (N : Natural) return Derived;
>
>         Failing_Object : A.The_Access_Type := B.Proc'Access;
>         --  will not compile, error: 'expected type The_Access_Type / found type
> access function Proc defined at ...'
>
>         function Proc_Wrapper (N : Natural) return Abstracted'Class;
>
>         Working_Object : A.The_Access_Type := B.Proc_Wrapper'Access;
>         -- compiler doesn't complain
>
> end B;
>
> package B body is
>         function Proc_Wrapper (N : Natural) return Abstracted'Class is
>         begin
>                 return Abstracted'Class'(Proc (N));
>         end Proc;
>
>         -- function Proc body ommited
> end B;
>
> ----------------------------------------
>
> What I need is a access type to 'constructor' of an derivate of abstract
> object.
> As I presented, there is a workaround, but that's not the 'right' way to do
> it. I really want to do it without some tricky wrapping.
> How do I define The_Access_Type to do what I want?

Others have posted discussions of how to accomplish what you want, or
what we think you might want, using a different construct.

I just wanted to point out that, from a low-level standpoint, there's
no way to have an access type that could refer to *both* a function
that returns Abstracted'Class *and* a function that returns the
specific type Derived.  The reason is that an access-to-function is
basically just going to hold the address of the function (and some
other information).  A function that returns T'Class can't work the
same as a function that returns a specific type, because the function
that returns T'Class won't know in advance how big the return object
is going to be, so some dynamic heap (or "secondary stack") allocation
must be involved.  A function that returns Derived, though, knows how
big the return object is, so the result can be pre-allocated.  This
means that both the function and the function's caller have to adopt
different mechanisms for passing the return object between them.  If
you have an access-to-function which could point to either one, the
code that makes a call through this access-to-function pointer isn't
going to know which return object mechanism would be used, so  the
result would be a mess.

If Ada were to provide a mechanism so that B.Proc'Access could be
used, the compiler would have to generate its own wrapper, same as
you're doing.  This isn't necessarily a bad thing; there are already
other cases where Ada compilers have to generate wrappers (at least
ours does).  But I think it's useful to understand the underlying
mechanisms involved, to get a better understanding of why the language
won't let you do certain things.

By the way, if you decide that the other suggestions don't work and
you need to write a wrapper anyway, you shouldn't have to rewrite the
whole wrapper for every type; I think you can use a generic to make
the process of declaring the wrapper a lot simpler.

                             -- Adam