Re: U : Unbounded_String := "bla bla bla"; (was: Is the Writing...)

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

Mark A. Biggar wrote:

> >   for Unbounded_String'Literal_Conversion use To_Unbounded_String;
> > 
> > (I understand that the same thing we can say using new pragma Literal_Conversion:
> > 
> >   pragma Literal_Conversion (Unbounded_String, To_Unbounded_String);
> > 
> > but I think that an attribute is somehow better here).
>
> With either of the above suggestions you probably also need to specify
> the type of literal allowed as well.  This would allow for multiple
> different types of literals to be used.

I don't know whether it makes sense to have multiple types of literals for
some private type. Are there appropriate examples?

But anyway, I see no problems with that in proposed notation: you have just
provide appropriate functions for conversion, with the same name (similarly
to usual overloading):

  type Flex is private;

  for Flex'Literal_Conversion use To_Flex;

  function To_Flex(Source : String) return Flex;

  function To_Flex(Source : Integer) return Flex;

Compiler will use one of those conversion functions depending on the literal
type it encountered. And I think that any other way to tell the compiler an
information for this purpose can't be better.

My concern is quite opposite: I'd like have a control for blocking such
overloadings (thus denying an opportunity for multiple literal types for a given
type), including those that may emerge within a derivation of a new type;
I don't know whether it is possible - to control that overloading - and it
worries me slightly. Although I don't count all that multiplicity of literal
types as too significant matter.



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