RE: what means the " ' " in use with a record type?

["Steven Deller" <deller@smsail.com>]

 >   If x is an access to type node, why is the qualified expression 
> > needed, while it's not needed in:
> >   type fruits is (apple, orange, banana);
> >   type colors is (red, orange, yellow);
> >   color : colors;
> >   fruit : fruits;
> > begin
> >   color := orange;
> >   fruit := orange;

T(x) is a type conversion (cast :-)) of x to type T.
The actual type of "x" need only be compatible with T, not "of" type T. 
 
T'(x) on the other hand is an "x" of type T.

Qualification is needed in many cases having nothing to do with
allocators.
See 4.7 for examples of some.

> As I recall, the original reason for the apostrophe is 
> because, in the absence of this feature, the general construct
>   new T(expr)
> could be ambiguous (or at least confusing to the human 
> reader) in some contexts -- i.e., is expr the value of a 
> discriminant, or is it an initialization for the allocated 
> object?  

No.  It means something different with and without the apostrophe.

If it were legal Ada to write:
   type A is access Node ;
   P : A ;
   ...
   P := new Node(x) ;
   ... or simply
   P := new (x) ;

then the type of x could be anything compatible with Node.  In
particular,
if Node were derived from N without any extensions, then x's value could
be of either Node or N.

That may seem trivial, until you consider type attributes, where N might
be allocated from shared memory (using a user-specified allocator), 
while Node is in default (non-shared) memory.

You could argue that Ada just ought to "do the simple/right thing", but
that is a slippery slope to C-style disasters. Better that the 
language force the writer to be specific about the type intended. 

Plus there is no "right" thing when you have tagged types with
extensions:
  procedure Test_Ada is
    type A is tagged record
        X : integer ;
    end record ;
    type B is tagged record
        Y : integer ;
    end record ;
    type C is tagged record
        Z : integer ;
    end record ;
    type P is access A'class ;
    O : P ;
  begin
    O := new B'(X => 3, others => 4 ) ; -- "B" or "C" is legal here
    ...                               ; Ada makes you say what you mean

Regards,
Steve Deller (the "other" SteveD :-))
deller@smsail.com