Literals for Private Types

["Alexandre E. Kopilovitch" <aek@vib.usr.pu.ru>]

Near 3 weeks ago I sent to Ada-Comment mailing list my proposal for literals
for private types. As no reaction followed there, I concluded that the proposal
sank in silence. Therefore I decided to post a brief and informal exposition
of that proposal here in comp.land.ada (I suppose that those people who might
be interested in full and more formal version are subscribed to Ada-Comment
and therefore already saw it). Here it is:

-----

1. Both String and numeric literals become possible for any user-defined type,
including private types.

2. Two new attributes is all that needed for that: Literal_Conversion attribute,
defines a family of conversion functions for a type, while With_Literals
attribute, being attached to a subprogram's formal parameter permits implicit
conversion of literal actual argument for the parameter.

The With_Literal attribute provides necessary control over ambiguity, which
always was a major obstacle for the issue of literals for user-defined types.

Appropriate parameters of all predefined operations of the type are considered
as equipped with the With_Literals attribute, so implicit conversions of
literal actual arguments is always permitted for them.

3. The Literal_Conversion attribute should be defined within the type's specs
by usual method:

  type T is ...;
  for T'Literal_Conversion use F; 

(function F must take single String or numeric argument and return T).

The With_Literals attribute need not be defined at all - actually it acts more
like a pragma, but an attribute form it is simply more natural and convenient
for the case:

  procedure P (Arg : in T'With_Literals);

4. With that proposal, the String literals for Unbounded_String type can be
introduced by adding exactly one statement to Ada.Strings.Unbounded specs:

  for Unbounded_String use To_Unbounded_String;

The direct effect of this addition will be an opportunity to assign String
literals to Unbounded_Strings without explicit conversion.

The subprograms defined in Ada.Strings.Unbounded package will not be affected
because they have no With_Literals attribute attached to their parameters.

Then, if we wish to allow implicit conversion from string literals for our
user-defined function Compare, we must use With_Literal attributes for its
parameters:

  function Compare (Source : in Unbounded_String'With_Literals;
                    Target : in Unbounded_String'With_Literals)
    return Boolean;

-----



Alexander Kopilovitch                      aek@vib.usr.pu.ru
Saint-Petersburg
Russia