Re: Discriminants or Constructor Function for Limited Types

["Randy Brukardt" <randy@rrsoftware.com>]

"Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de> wrote in message 
news:t4ti4a$s1u$1@gioia.aioe.org...
> On 2022-05-04 11:02, R R wrote:
>> There are two ways (to my knowledge) how to initialize objects of limited 
>> types. Either the limited type has some discriminants
>>
>>     type DLT (Width, Length : Positive) is tagged limited private;
>>     Obj : DLT (3, 5);
>>
>> or I can provide a constructor function that takes corresponding 
>> parameters
>>
>>     type LT (<>) is tagged limited private;
>>     function Make (Width, Length : Positive) return LT;
>>     Obj : LT := Make (3, 5);
>>
>> Do you recommend one way over the other? Why? Is it possible to combine 
>> both methods (discriminants plus constructor)?
>
> Two more ways are allocators and limited aggregates.
>
> There is no good way to safely initialize a limited object because Ada 
> lacks proper constructors and because the initialization model is 
> inherently unsafe with regard or exceptions, task components, 
> self-referential discriminants (AKA Rosen's trick).
>
> But there are numerous hacks and workarounds depending on the objective.

Those cases that you worry are "unsafe" seem to me to only occur because of 
"hacks and workarounds". There's no good reason to do any of those things 
intentionally unless you are using a "hack" to do something dubious in the 
first place.

To answer the OPs question, the reason to prefer one initialization scheme 
over another mainly comes down to how you are going to use the type. If you 
don't expect it to be composed with other types, use whatever is comfortable 
(I ususally use a procedute in such cases, and have the type self-initialize 
to "invalid" so it can't be used until a call is made).

If you need to compose the type with other similar types, it helps to use 
the same initialization mechanism for all (that is, it's easiest to 
initialize discriminants with other enclosing discriminants, and initialize 
via a function from another function).

Also note that you can combine discriminants with the (automatically called) 
controlled type procedure Initialize to do more complex initialization based 
on the discriminants. My preference is to make almost all new types 
controlled, not everyone agrees with that.

                             Randy.