Re: Practicalities of Ada for app development

["Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de>]

On Mon, 11 Jun 2012 22:50:33 +0200, Georg Bauhaus wrote:

> Reason: numeric literals typically mean a number of some "arithmetic"
> type.

No, a numeric literal means what it tells "a number."

> U+number is similar to the explicit checking of units (and possibly
> values) in
> 
>    Some_Time_Object :=  45 * Seconds;
>
> presented in Barnes's book.

Technically Barnes is not quite right. A correct expression should be:

   Some_Duration_Object := 45.0 * s;

1. 45.0 is floating-point;
2. You cannot multiply time, you do durations (time intervals);
3. "s" or "second" is the proper name of the unit.

http://www.dmitry-kazakov.de/ada/units.htm

> When using U+number, the checks are performed by one subprogram ("+").

Code points are numbers, not dimensioned numbers. Dimensioned numbers form
a structure different from one of the code points. You are confusing type
and dimension. Dimension is one characteristic of some types, e.g. a
constraint, but not every type is dimensioned.

> A different design might (but need not) require checking in many places.
> U+number feels a bit like using a "constructor" for literals.

Literal per definition cannot be a constructor. Its name reveals that:
literal is denotes a value, e.g. a number, "literally." Furthermore,
literal is a syntactic notion (expression term), while constructors are
related to the program semantics (create objects from raw memory).

Anyway, the point stands: in a properly typed languages you need no special
forms of literals. I guess that U+n stems from C-ish nL, nU etc. These are
syntactic inventions necessary in C because the language is incapable to
resolve ambiguity using the result type. C is bottom up. Ada is not bottom
up. You can overload numeric literals in almost any context in Ada. So you
don't need silly tricks like U+n.

>> BTW, as practice shows, code points are used rarely and almost always as an
>> argument for conversion to a UTF-8 string.
> 
> OK. I imagine, though, that most US programming styles will suggest not to
> write non-7-bit source text. When I need a UTF-8 encoded literal PI, wouldn't
> I then need to write something like the following?
> 
>   PI : constant UTF_8_String :=
>     Character'Val (16#CF#)
>   & Character'Val (16#80#)
>   & Character'Val (16#0A#);

No. The proper way to do this is:

   UTF8_Pi : constant String := Image (16#0C30#);

http://www.dmitry-kazakov.de/ada/strings_edit.htm#Strings_Edit.UTF8

-- 
Regards,
Dmitry A. Kazakov
http://www.dmitry-kazakov.de