Re: tagged types extensions - language design question

["Matthew Heaney" <matthew_heaney@acm.org>]

In article <s9av7kh45io46@corp.supernews.com> , "Vladimir Olensky" 
<vladimir_olensky@yahoo.com> wrote:

> Yes, as a matter of fact  this is not a big deal.
> Actually everything needed could be declared  in one package.
> One need just to remember the right sequence - first to declare
> abstract public extension of the root type, then it's abstract private
> extension and then concrete final extensions (in my case two of them).

Yes, you have to declare the public part of abstraction first.

> Very similar to the case when one wants to declare deallocation
> procedure for some private type in the same package where this
> private type is declared. Here right sequence is also very important
> and might be even less obvious for those who encounter that need
> for the first time.

If you have a "by-reference" abstraction, that is, an abstraction
designated by a pointer, then there's an idiom for that too.

(You need to put objects on the heap when you have "containment by
reference," instead of "containment by value," as is often the case when
doing class-wide programming.)

Basically, you declare the type as limited and indefinite, and declare
all primitive operations with access parameters:

package P is

  type T (<>) is abstract tagged limited private;

  type T_Access is access all T'Class;
  for T_Access'Storage_Size use 0;

  procedure Op (O : access T);
...
end P;

Non-abstract types in the class declare a constructor for the type:

package P.C is

  type NT is new T with private;

  function New_NT return T_Access;  -- possibly NT_Access

  procedure Op (O : access NT);
...
end P.C;


That all types in the class are limited and indefinite prevents clients
from declaring their own instances directly.  You want to force them to
use your constructor.

In general, a client should never invoke an allocator ("new T")
directly.  Give them a constructor, and invoke the allocator internally.

The other issue is how to reclaim instances.  You can either provide:

1) a classwide Free operation (declared in the root package, and
implemented by calling an instantiation of Unchecked_Deallocation, or by
calling a private dispatching deconstructor)

2) instead of using an access type, use a smart pointer, and let
deallocation be automatically


Both of these techniques are in the patterns archive (which I'm about to
do some maintenance of).

<http://www.acm.org/archives/patterns.html>