Foreach Range Statement

[Bill Baxter]

Reiner Pope wrote:
> Bill Baxter wrote:
>> Jarrett Billingsley wrote:
>>> "Xinok" <xnknet at gmail.com> wrote in message 
>>> news:f80qof$2n0l$1 at digitalmars.com...
>>>
>>>> foreach(i; 0..100)
>>>
>>> This is almost identical to the syntax in MiniD:
>>>
>>> for(i: 0 .. 100)
>>>
>>> It could be done with for or foreach; I just chose for because 
>>> normally you use for loops to iterate over ranges of integers.
>>>
>>> You can also come up with a pretty simple short-term solution that'll 
>>> be fairly efficient (though not as efficient as if the compiler were 
>>> aware of this kind of loop intrinsically) by making a struct 'range' 
>>> which has a static opCall to construct a range and an opApply to 
>>> iterate over the values, so that it'd look like:
>>>
>>> foreach(i; range(100))
>>>
>>> Which isn't terrible at all. 
>>
>> And it has the advantage of being more extensible.  And for allowing 
>> ranges to be treated as first class entities that can be passed around 
>> and manipulated.  But no, instead we get another one-trick pony.
>>
>> --bb
> That was my first thought, too.
> 
> In the "Array Slice Ranges" thread, several people mentioned first-class 
> ranges:
> 
> http://www.digitalmars.com/pnews/read.php?server=news.digitalmars.com&group=digitalmars.D&artnum=43865 
> 
> http://www.digitalmars.com/pnews/read.php?server=news.digitalmars.com&group=digitalmars.D&artnum=43904 
> 
> http://www.digitalmars.com/pnews/read.php?server=news.digitalmars.com&group=digitalmars.D&artnum=43905 
> 
> http://www.digitalmars.com/pnews/read.php?server=news.digitalmars.com&group=digitalmars.D&artnum=43954 
> 
> 
> Your implementation, Bill, seems to be just right, and gives you foreach 
> over ranges for free.

Thanks.  I think Oskar Linde had a nice version too.  I seem to remember 
thinking there were a few things in his that I should borrow.

> What's wrong with adding that to the language, but templated and with 
> nice syntax?
> 
> type name                                 literal
> int..int  (range of int)                  1..5
> int..double   (range of int to double)    1..5.0
> int..int:int  (stepped range)             5..1:-1
> 
> (I'm not sure of the use of mixed-type ranges, but this seems the most 
> intuitive syntax. Since most ranges are probably of one type, how about 
> allowing a symbol to denote "same type again". Any of the following 
> could mean int..int:   int..#,   int.._, int..$)

Having two different types for it seems odd.  Just plain int.. would 
make more sense to me.  I really like that 5..1:-1 syntax though!  Was 
that mentioned before?  Something about all the colons in Pythons range 
literals always makes me uneasy.  a:b:c -- is that a to c stepping by b? 
  Or a to b stepping by c?  In Python it's the latter.  In Matlab I 
think it's the former.  Which is probably why I always feel a little 
uneasy when I see it.  But a..b:c is much clearer!  Obviously it's from 
a to b, so c must be a step.  And the colon looking like the two dots 
stood on end -- lovely.

> As several people have pointed out, this also fixes mixed 
> indexing/slicing problems for multi-dimensional arrays.

To give Walter the benefit of the doubt, perhaps this new addition *is* 
the first stage of just such a master plan to make range literals first 
class citizens.


--bb