Re: Constructing an object

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

"Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de> wrote in message
news:3dachnu33lly.fpr0wvf6nj05$.dlg@40tude.net...
> On Sat, 24 Sep 2005 00:23:01 -0500, Randy Brukardt wrote:
>
> > In Ada 200Y, access discriminants are allowed on nonlimited
> > types, but they then cannot have defaults (such discriminants cannot
change
> > after object creation, and we needed to disallow changing them via
> > assignment).
>
> How? The type should be then abstract or unconstrained and the user should
> have rather its subtype with the discriminant limited to the value.

If the discriminants don't have defaults, the type *is* unconstrained. The
user has to provide the discriminant value with the object declaration or
initial value, or from a subtype declaration that is then used to create
object.

> > You also failed to mention that the object factory can be implemented
> > (probably *ought* to be implemented) with the Ada 200Y
> > Generic_Dispatching_Constructor. That takes a tag value and a
dispatching
> > function and creates an appropriate object for the tag, initialized by
the
> > dispatching function.
>
> That is a good news, though it still looks like hack.

It *is* a hack! A hack is better than the Ada 95 situation (no way to do
it). The whole idea is simply to provide a way to make the mechanism that
compilers have visible to the user.

> Generics is used to
> pass the parameters, instead of providing some native mechanism for
> determining the tag, discriminants, bounds and other constraints.

We tried a lot of those, but they all fail because Ada allows discriminants
on tagged types. That makes it necessary for the user code to create the
object; doing the operations separately is not an option. The only thing
that I know *would* work (new syntax to allow dispatching on a provided tag
value) was considered way too heavyweight for a relatively minor problem.

> One
> possibility could be to have for each type a predefined null-record type
> having the same discriminants (tag and bounds are mapped to
discriminants).
> Then the object of this type could be passed to the allocator.

What allocator? The critical part of the whole scheme is that there is no
allocator required; this works just as well on stack objects as it does on
heap-allocated objects. It should never be necessary to use heap-allocated
objects (or syntax like 'Access and .all) to get the benefits of O-O design.

> IMO there should be proper constructors for all types. Constructing
> functions are too error-prone.

No one agreed with that. The only problem with using functions for
constructors was the weird semantics for limited types, which was solved by
getting rid of those semantics. If you want to ensure that constructor
functions are used, you need to declare your types with (<>) discriminants.

> Further, Ada needs extensible primitive and
> class-wide operations, that could finally solve the construction /
> assignment problem.

I have no idea what this means; Ada has extensible primitive operations
(indeed, *only* primitive operations can be extended).

                       Randy.