Re: Syntax for tagged record types (was Re: Not intended for use in medical,)

[eachus@spectre.mitre.org (Robert I. Eachus)]

In article <mheaney-ya023680002405971626500001@news.ni.net> mheaney@ni.net (Matthew Heaney) writes:

  > Maybe not: we just need some way of allocating the object on the
  > stack, and letting the constructor manipulate that object, so that
  > no copying is ever required.  It would be really swell too, if in
  > the constructor we were able to invoke the constructors for the
  > object's components.

  > An important goal, though, is for constructors for limited types
  > that are indefinate.

  Hmmm.  Let's imagine a generic package:

  generic
    type Object_Type(<>) is limited private;
    type Object_Ref is access Object_Type;
    ...
  package Constructor is
    Object: Object_Ref;
  end Constructor;
  pragma Elaborate_Body(Constructor);

  package body Constructor is
    ...
  end Constructor;

    Now every time I instantiate this package, I create an Object_Ref,
and in the body I initialize it to point to a value in the body.  For
some types the body can be completely in Ada, for others you might
have to use extensions/magic tricks/Unchecked_Conversions, etc. in the
body, and in particular, the decision whether or not to call
Unchecked_Access will almost certainly a significant design issue.

   When I have played this game, I've done it three different ways:

   1) N objects in the package which declares the type, and the
generic packages do reference counting.  (Actually, it is easier to
make the _ref type a controlled type to begin with, but I digress.)

   2) Unchecked_Access and programming standards about copying the
pointer object.  (Or you could try making that type limited, but leave
out the unknown discriminants.)

   3) Garbage collection provided courtesy of Unbounded_String. Be
careful to understand the game here.  The safest is to have a
(private) token type which is access Unbounded_String, and a
conversion which produces an Object_Ref from it.  To do otherwise, you
have to look at the implementation of Unbounded_String.
--

					Robert I. Eachus

with Standard_Disclaimer;
use  Standard_Disclaimer;
function Message (Text: in Clever_Ideas) return Better_Ideas is...