[fpc-devel] "case" with range stupidities
JeLlyFish.software at gmx.net
Thu Feb 15 15:20:11 CET 2007
On Thursday 15 February 2007 13:36, Daniël Mantione wrote:
> Op Thu, 15 Feb 2007, schreef Vinzent Hoefler:
> > Well, fair enough, but why is that I can declare a
> > type
> > Foo = array[byte] of Something;
> > where the type name "byte" also indicates the range? Considering
> > that
> > type
> > Foo = array[Low (byte) .. High (byte) of Something;
> > is totally equivalent, the allowed usage of range types seems a
> > little bit inconsistent...
> Yes, but as I said, case labels are a set, not just a range:
> const x=[0,1,5];
> type foo=array[x] of something
> ...would again be rather weird.
It would be, yes. It even seems constants can't be used in an array type
declaration at all (well, not in a way different from defining the
lower and upper bound, I mean) and
X = 0 .. 5;
does not work either while "type X = (Zero, One, Five)" would do both
So in short: it seems a range type like "byte" can be used where a
"pure" range is expected, but it cannot be used where a set is expected
(like for a case label, even though there a set constant would not be
-- 8< --
X = (Zero, One, Five);
Bla : X;
Foobar = [Zero, One];
Bla := Five;
case Bla of
Low (Foobar) .. High (Foobar) : WriteLn ('Less than Five.');
// The following two lines don't work, of course.
//Foobar : WriteLn ('NO.');
//[Foobar] : WriteLn ('NO.');
WriteLn ('More than One, I guess.');
// A real set operation.
if Bla in Foobar then
WriteLn ('Really less than Five.')
WriteLn ('Wrong. It is NOT less than five!');
-- 8< --
So if the case label is considered a set why can't I use a set constant
(see the commented lines above) and if I do the range thing, which
compiles, it does not consider the value of the constant but rather the
range of its /type/...?
Seems to me that case labels are very special things, at least.
Another oddity would be a for loop:
for Bla := One to Five do ...
would be a range only, yes? (Apart from the fact that - due to the "to"
keyword - really isn't).
So wouldn't it be easier to write
| for Bla := X do ...
here, when X is some range type, I'd like to iterate over? Again I have
to Write "Low (X) to High (X)" quite similar to the "case" case.
I suppose changing that behaviour regarding range types is not an option
at all, so I'd ask for some other improvement:
What about a compiler built-in like Low() and High() called Range()
where its return type indicates something that would be compatible to a
case and for label and just denote the range of the whole type?
Basically a short cut to the "Low (Type) ..|to High (Type)" expression,
but without the possible pitfall of writing
Low (Type) .. High (A_Similar_And_Unfortunately_Compatible_Type)
and thus being less error-prone...?
I mean, doing:
|for Bla := Range (X) do
|case Bla in
|Range (X): ...
doesn't actually look unreadable to me...
More information about the fpc-devel