Re: S-expression I/O in Ada

[Robert A Duff <bobduff@shell01.TheWorld.com>]

"Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de> writes:

> On Sun, 08 Aug 2010 16:03:22 -0400, Robert A Duff wrote:
>
>> For scalars, the primitive operations mostly don't know the
>> subtype bounds -- they are operations of the type.  So this
>> wouldn't fit into Ada well.
>
> But array subtypes silently modify their operations or, if you want,
> parametrize them using the dope.

Yes, and discriminated subtypes are similar to arrays in that way.
The dividing line is "scalar" vs. "composite".  (I'm not sure that's
a good idea, but that's Ada.) You are suggesting to make modular
types (a kind of scalar) work more like composites, which doesn't
fit well, even if it's a good idea in the abstract.

I actually have no opinion whether it's a good idea, because I
don't like modular types in the first place.  ;-)

I didn't mention "access" above, which are "elementary" but not
"scalar".  Constrained access subtypes are a nightmare!

>... A modular subtype would have a dope as
> well.

They already do, but the arithmetic ops don't consult that dope.

>>> ...then they could be used as indices.
>> 
>> The problem I was alluding to is that if you have
>> an unconstrained array type, sooner or later you might
>> have an empty one.  So you want bounds 0..-1, but -1
>> wraps around.
>
> Empty range does not have bounds.

Except that in Ada, they do.  An empty String is (1..0).
It could also be 10..9 or even -100..-10_000_000, but
that's not a good idea.

>...What are bounds of
>
>    type Empty is mod 0; -- Illegal in Ada, but must be legal
>
>> Same thing with a "for" loop that goes from T'First up to
>> something.
>
> If ranges (contiguous sets of indices) were proper types you would be able
> to construct them in many different ways. E.g.
>
>    function ":" (From : Index; Length : Universal_Integer)
>       return Index'Range
>
>    L := 0
>    ...
>    for I in T'First :L loop
>
> instead of what you can find in every Ada program:
>
>    for I in T'First..T'First + L - 1 loop
>
> or for enumerations:
>
>    for I in T'First..T'Val (T'Pos (T'First) + L - 1) loop
>
> which does not work anyway...

Good points.

>> If 2..10 wrapped around, then you'd want range 2..1, which
>> has the same problem.
>
> 2..1 actually is 2,3,4,5,6,7,8,9,1
>
> Modular numbers are not ordered.

But they are -- they have "<", and "for" and so on.
Perhaps they _should_ be unordered, but I won't agree or disagree,
since I think in an ideal world they should be banished.

By the way, one defense of modular types I've heard is that
they are used in mathematics.  True.  But mathematicians do
not use _implicit_ mod.  They say things like "X = Y (mod N)",
which is pronounced "X is congruent to Y (modulo N)".
Congruent, not equal.

- Bob