Re: Initializing an array of tasks with discrimants

[Jere <jhb.chat@gmail.com>]

On Friday, November 22, 2019 at 5:39:57 PM UTC-5, Jeffrey R. Carter wrote:
> On 11/22/19 11:07 PM, Jere wrote:
> > I recently ran into a situation where I had an array
> > of tasks that had discriminants (with a default), but
> > I couldn't find a simple way to initialize them.  I
> > did come up with a workaround, but wanted to see if
> > the language defined a way to do this:
> 
> The standard way to do this is for the default to be a function call:
> 
> Next_Value : Positive := 1;
> 
> function Next return Positive is
>     Result : constant Positive := Next_Value;
> begin -- Next
>     Next_Value := Next_Value + 1;
> 
>     return Result;
> end Next;
> 
> task type T (D : Positive := Next);
> 
> type T_List is array (Positive range <>) of T;
> 
> A : T_List (1 .. Num_Tasks);
> 
> The language guarantees that the calls to Next will occur sequentially. The 
> order of the calls is not defined, so there is no guarantee that the index and 
> discriminant of a T in A will be the same.
> 

Thanks!  That said, my issue isn't so much generating the numbers
(They would not have any particular pattern anyways), but trying
to figure out if there is an aggregate or qualified expression for
initializing tasks with discriminants that I could use.  I was hoping
that simply T'(D => 2) would have worked, but the compiler complains
about being a composite.  On one level I understand why, but on another
given how strongly typed Ada is, I was hoping the language provided
some type of initialization aggregate.

This is still a good solution for when the discriminants will have  a
known pattern by design though.  I will file it away for that
situation, so thank you.