First class lazy Interval

[bearophile]

Don:

>How do you specify a uint range that includes uint.max?<

The interval I was talking about may generate integers only (it may be possible to generate longs and chars too if you give it long/char extrema, but I am not sure this is a good idea).


>This is a perfect example of what Andrei recently posted: proposal of a language change for a pathetically limited special case. Your stride is not powerful enough to be worthwhile.<

It's limited on purpose, but such intervals are useful in many situations.

And note such interval is less limited than the current syntax of D2, that allows such interval as foreach argument only.

This post of mine was just an idea, surely most of it can be improved :-)

---------------------

Daniel Keep:

>[a,b] is inclusive, (a,b) is exclusive and [a..b] is lower inclusive, upper exclusive (to match slicing syntax).<

I'll probably not be able to remember that. What I'm looking for is something simple that covers the most common cases, not all of them introducing excessive burden to the memory. In designing such things the 80/20 rule is good.

---------------------

Don:

> So desirable syntax like auto y = x[2..$, 4, 3..8]; is impossible.<

I see. 

In Haskell you can use the syntax [x..] to denote the half interval of integers from x to infinite.

So in D2 x..$ may be used to denote an interval infinte on the right... or (contextual-wise) one interval extended to the max possible value (max int, or max length of the iterable/data structure?). I am not sure such double meaning is a good thing.

---------------------

Lutger:

>About the stride, in ruby this is done as (0..10).step(2), which is very readable imho.<

It's more readable than
0 .. 10 .. 2
but I think you can get used to 0..10..2 too, because you probably end using such syntax often in programs.

---------------------

Sean Reque:

>but Ruby also supports instantiating them using perl's syntax, which underneath the hood is just creating a Regexp object. The advantage of the perl-like syntax is that editors and IDEs can aid a user with syntax highlighting, whereas when creating a regular expression with a string no such help can be given.<

Languages are designed for different purposes and with different ideas in mind. Syntax-wise Python is simpler, less tricky (*) and more uniform than Ruby. This makes Python less complex to learn, but less able to create custom-purpose sub-languages, etc.

(* = see functions called as foo 5)


>Doing things similarly in D, one could implement intervals in a library form in a similar manner as Daniel did, and then add support in the language for the syntax bearophile described.<

Few weeks ago I have suggested to adopt a similar strategy in D too, for example to implement complex numbers, multi-precision numbers, and few other things. The compiler can implement just the syntax and a default "bridge" from such syntax and the logic that is contained into a normal D module of the std lib. So for example you can write:

Bigint a = 123_456_789_123_456_789_123_456_789;
Bigint b = 987_654_321_987_654_321_987_654_321;
c = a * b;

Where the compiler has a built-in support such natural syntax for Bigints literals (or complex number literals), but the operations like the multiplication among such Bigints are implemented in D into the std.bigints module and not into the compiler. I don't actually know if such idea can be implemented in a D compiler, no one has answered me about this so far :-)

---------------------

A possible small problem:
Floating-point linear ranges (as used in matlab and numPy, etc) are often useful, but the 0..10 and 0..10..2 syntax doesn't look much good if you want to re-use it for floats (or even for interval arithmetic) because all those points may be too much confusing, even if you add spaces:

0.0 .. 10.5 .. 0.5
0. .. 10. .. .5

So intervals may be kept for integral values only.

As an alternative syntax may be:

foreach (i; 1:10) {...}
foreach (i; 10 : 1 : -1) {...}
foreach (i; 0.0 : 10.5 : 0.5) {...}

Bye,
bearophile