[fpc-devel] Limitations of static "ranged" integer types and succ/pred, and dynamic solution.

[Vinzent Höfler]

On Tue, 20 Dec 2011 07:41:50 +0100, Skybuck Flying  
<skybuck2000 at hotmail.com> wrote:

> (Delphi limitation, but probably applies to free pascal as well):

You have a very interesting definition of "limitation", but well...

> Take following examples:
>
> Tvalue = smallint;
>
> or
> Tvalue = word
>
> or
>
> Tvalue = 0..5000;
>
> ^ All of these examples are quite bad in the following way:
>
> They become very static, which makes it pretty much impossible to change
> their range at runtime.

I can't see any reason why you would even want to change a range during
runtime. After all, there usually was a pretty good reason why you applied
a range the first time, otherwise you would have used Integer directly.

> My recommendation for the Delphi language is to do away with these static
> types and instead change them to dynamic types, just like arrays where
> expanded with dynamic types.

As if the only purpose of range types is to index dynamic arrays.

> Ofcourse it's nice and perhaps even required to keep these static types  
> for
> backward compatibility but it would also be nice if these types can be
> expanded with a dynamic type, so it can be safely used with dynamic  
> arrays
> which can be any size/range.

In that case you just need one type: InfiniteInteger (or maybe call it
UnconstrainedInteger), where it's bit size changes during runtime up to
the point where the computer memory is exhausted. So, instead of getting
Range-Check errors, you get memory allocation failures trying to allocate
an integer requiring 2**128 bits. :->

> var
>   MinValue : integer;
>   MaxValue : integer;
>
> Tvalue = MinValue...MaxValue;
>
> then this type could also be used as follows:
>
> var
>   DynamicArrayOfValues : array[Tvalue] of integer;

Umm, and what shall happen, if I change MinValue somewhere inbetween? The
array size and/or index range shall magically change with it?

And why would that be better than a (more) simple

var
    Dynamic : array[MinValue .. MaxValue] of Integer;

type
    TValue = Low (Dynamic) .. High (Dynamic);

The array and the type you're indexing it with are tied to each other  
either
way, so there's no point in changing only one of it. Or, to express it
differently: As long as you don't know the size of the array you also don't
know the range of the index type - and vice versa.

Well, considering that the latter is (to some extent) already available in  
the
current compiler, your proposal is IMO quite useless.

Or - may I speak freely, sir? ... Then, I think, it's bullshit.


Vinzent.