Re: Why no Ada.Wide_Directories?

["Yannick Duchêne (Hibou57)" <yannick_duchene@yahoo.fr>]

Le Tue, 18 Oct 2011 06:46:13 +0200, ytomino <aghia05@gmail.com> a écrit:

> Well...If my supplement is allowed, in my honest opinion ignoring the
> existing way of Ada, "File_Name_String" is better.
> (In addition, It's  welcome that UTF_8_String and UTF_16_String be new
> types like Yannick says.)
For personal and specific use cases, yes, however, for a standard, I would  
be more in favor of an Unicode_String type. To be honest, my dream would  
be to replace the Ada String type with that Unicode_String type (a dream…  
I said). I use to attempt to create packages where the String type was  
redefined, but failed due to some scope trouble (could never make my mind  
about wither or not this was a GNAT bug or not).

This is important, because UTF-8, vs UTF-16LE, UTF-16BE and even possibly  
UTF-32BE and UTF-32LE, is only a matter of implementation and is not a  
good candidate for an interface, unless participating in a specific use  
case.

Unicode_String implementation could be optionally encoded, or not, at the  
sole discretion of implementation. The implementation could use UTF-32 if  
it wish to be simple, or be in favor of the same encoding as the target  
platform. This Unicode_String type would have method to return a  
conversion into one of UTF-8, UTF-16 and UTF-32, and optionally (may raise  
runtime error) to ISO-8859-1. For efficiency, this could also provide  
primitive for common iterated composition, such as concatenation, getting  
slice, comparison (which can be implemented far more efficiently at the  
implementation level, that by mean getting and setting character, which  
involve encoding and decoding each time). I would also suggest a  
Change_To_Uppercase (Unicode_String, Index), and the same with  
Change_To_Lower_Case, along with a Remove_Slice and Insert_Slice  
primitives. These primitive would cover most of use case and help preserve  
efficiency.

This could also solve a glitch. Actually, if you want to store UTF-8  
string in an Ada source, you have to cheat the compiler: edit the file as  
UTF-8, and compile as if it was ISO-8859-1 (*). Unfortunately, this is not  
clean. If there was a real Unicode_String type (or the String type changed  
into a Unicode one… in my dreams), this would not be a trouble any more.

On the other hand, if this would cause troubles to Ada, I prefer no  
change, and to go on with personal methods.

(*) You can do the same for UTF-16, with some variation: use  
Wide_Character for your string, edit sources in UTF-16, and cheat the  
compiler telling him the sources are UCS2 encoded (note: UCS2 is another  
no-encoding Unicode subset, the same way ISO-8859-1 is, except two bytes  
wide instead of one byte wide).

-- 
“Syntactic sugar causes cancer of the semi-colons.”  [Epigrams on  
Programming — Alan J. — P. Yale University]
“Structured Programming supports the law of the excluded muddle.” [Idem]
Java: Write once, Never revisit