Re: Limited use for limited with?

[Ludovic Brenta <ludovic@ludovic-brenta.org>]

Maciej Sobczak wrote on comp.lang.ada:
> So let's say that I already did the thinking and the most prevalent
> use case for access types is callback registration.
>
> Think about AWS dispatchers for the closest analogy.
> In fact, the AWS.Server.Start procedure has a version that takes the
> callback by access. It is an access to function, but I need it to be
> object-oriented.

OK, functors then (I believe this word is C++ jargon).

> Hiding the use of access values behind the scenes (by virtue of tagged
> types being always passed by reference) would obstruct the code
> without clear benefit. This is what AWS does in its other versions of
> Start, but I don't like it.

Do you mean you don't like this one:

   procedure Start
     (Web_Server : in out HTTP;
      Dispatcher : Dispatchers.Handler'Class;
      Config     : AWS.Config.Object);

Personally it is the one I prefer. Why do you not like it?

> I want to express this:
>
> 1. Object is an interface type for the callback that will be
> implemented by user.
> 2. Object_Access is a type that will be used for declaring and passing
> around callback references. I don't want everybody to define their own
> types for what is a common functionality.

I don't think this functionality is that common; ideally the only
things you have to do with such references is record them in a
registry and then dereference them to call the callbacks. You wouldn't
"pass around" such references very often, I think. Especially if your
callbacks are allocated at elaboration and not dynamically on the
heap.

> I totally agree that in Ada the pressure for using access values is
> much smaller than in C++, but object registration (in a map, perhaps)
> is not addressed by any other language feature.

I would probably use an instance of Ada.Containers.Indefinite_Vectors
or Indefinite_Doubly_Linked_Lists to hold an ordered list of class-
wide callback objects. Is that the language feature you were looking
for? Granted, such a container would duplicate the callback objects
("functors") in memory; using access values would avoid that.

> Should I drop the Object_Access type altogether and mess with locally-
> defined access types in other parts of the code?

I would define the access type in the package that defines the
registry of callback objects, e.g.

limited with Objects;
package Registry is
   type Callback is access all Objects.Object'Class;
   procedure Register (C : in Callback);
   procedure Call_All_Callbacks_In_Registration_Order;
end Registry;

--
Ludovic Brenta.