Re: Ada 200X Assertions

["Mark Lundquist" <mlundquist2@attbi.com>]

"Lutz Donnerhacke" <lutz@iks-jena.de> wrote in message
news:slrna0stp1.pjb.lutz@belenus.iks-jena.de...
> * Matthew Heaney wrote:
> >"Lutz Donnerhacke" <lutz@iks-jena.de> wrote in message
> >> Typical example 2: A head node of a linked list contains a next pointer
> >>     which should be handled exactly as the next pointer of the real
> >>     list nodes, but no payload at all.
> >
> >In the code below, I do this by making the List_Type a private derivation
of
> >a Node_Type. Which means a List_Type, containing only the head pointer,
can
> >be used exactly like Node_Type.
>
> >   type Node_Type is abstract tagged private;
> >   type List_Type is new Node_Type with private;
>
> That's not a generic mixin.
>
> My job is:
>   task type Bla is ...;
>   type Blas is array (Positive range <>) of Bla;
>   type Foo (len : Natural) is abstract record
>     t : Bla (Positive'First .. len);
>   end record;
>   procedure Process (a : Foo) is abstract;
>
>   package Bla_List is new List (Bla);
>   package Bla_List2 is new List (Bla);

Well, what you have there is not really a mixin, either.  That's just a
"plain old" generic list :-) (POGL).

The mixin idiom takes a generic formal tagged type, and exports an extension
of that type with additional properties/behaviors.

The POGL gives you an "externally-linked"/"containing"/"value-oriented"
list, where the collection owns the items.  The mixin gives you an
"internally-linked"/"by reference"/"object-oriented" list, where the client
owns the items.

Now... I'll bet you can take the example I wrote, or the one Matt wrote, and
figure out how to make either a generic mixin, or a plain old generic list,
with a header using the access discriminant technique.

Your example is of a list of tasks.  Since these are limited, you have two
ways to go:

1) Use a POGL (as shown in your example).  That POGL will have to have the
formal item type as limited; such a POGL does not do any assignments to the
items, even though it owns and creates them.  Instead, it returns pointers
to the items.

2) Use a mixin on a tagged container type, like this:

    type Bla_Container is tagged record
        Contents : Bla;
    end record;

    package Bla_Lists is new Lists_Mixin (Base => Bla);
    subtype Listable_Bla is Bla_Lists.Item_Type;                -- whatever


Best,
Mark