Re: S-expression I/O in Ada

["Randy Brukardt" <randy@rrsoftware.com>]

"Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de> wrote in message 
news:iv3qwjogornz$.1s8kq0yfl2wxl.dlg@40tude.net...
...
> Conversion mess is what we already have right now. The point is that "+" 
> is
> well-defined and meaningful for octets, but it is not closed in there. Why
>
>   function "**" (Left : T; Right : Natural) return T;
>   function S'Pos(Arg : S'Base) return universal_integer;
>   ...
>
> are OK and "+" is not?

The first has the same operand and result type (the power operand is 
something else and not really part of the operator IMHO). The second is the 
long winded name for a conversion operator - it implies no semantic change. 
I'm arguing that operations like S'Pos would be better having a common name 
like "#" rather than a host of specialized names.

>> Since we're inventing things, I would suggest:
>>
>>    -- Conversion function (Not Ada):
>>    function "#" (Right : Octet) return Universal_Integer;
>>
>>    Little_Endian_Value := #Octet_1 + #Octet_2 * 256;
>>
>> And now you don't need any Octet math.
>
> 1. What is this else?

Huh? This doesn't parse.

> 2. I see no advantage over
>
>   Little_Endian_Value := Integer (Octet_1) + Integer (Octet_2) * 256;

"#" can be overridden and/or user-defined. "Integer" cannot (and could never 
be in a version of Ada, as any such attempt would be way too incompatible). 
In addition, "#" is more readable in the 98% of the cases where you don't 
need to specify a type. I would probably consider using predefined versions 
of "#" to replace other forms of explicit type conversion as well (so "#" 
would always work if defined - no decision about whether to call a function, 
use a built-in type conversion, or use some attribute - and no need to look 
up the name of the type).

>> BTW, the "#" operator was suggested by Jean Ichbiah and others back 
>> during
>> the design of Ada 83, to be used for conversions between types. It's a 
>> pity
>> that it or something like it never made it into Ada. (It comes up each 
>> time
>> and still is rejected.)
>
> It would be nice to have more operators  than now ("^", "|", "..", "in",
> ":=", "<>", "()", "[]", "{}", "<=>", "@", "~" and so on. Ah, Ada is 
> Unicode
> now, here is the list: http://www.unicode.org/charts/PDF/U2200.pdf ).
>
> But what is so special in type conversions, aren't they just functions?

That's the point: in Ada, type conversions are *not* functions, they're a 
built-in gizmo [including some attributed]; by naming them "#" we would 
allow unifying them with functions. Of course, this could be abused (by 
having some semantic change encoded in the function as well), but that of 
course can happen just as well with "+" or "-" or "*".

                                        Randy.