foreach

[bearophile via Digitalmars-d]

The idea of using code like this (only one or the other should be 
allowed) is rather natural, it breaks nothing, it avoids the 
programmer to introduce a variable that is not needed, making the 
code less noisy:

foreach (;0 .. 10) {...}
foreach (0 .. 10) {...}

I don't see the need for so many posts against this simple and 
innocous idea that's a small improvement. Improvements don't need 
to be large to be good, if their price is correspondingly small 
(as in this case). (With an attitude like the current one no 
small positive feature like the "_" to separate digits in numbers 
literals could have seen the light).


With a little breaking change "_" could become a name that can't 
be referenced, so you can also do:

foreach (_; 0 .. 10) { // OK
   foreach (_; 0 .. 20) { // OK
     writeln(_); // syntax error
   }
}


Or:

foreach (immutable i, _; items) {...}


The _ can also be used as "don't care" for tuple unpacking, this 
is a very important usage:

t{_, b} = fooAB();


And in switch on structs (that contain the optional "unapply" 
method):

switch (foo) {
   case Foo(x, _, _): writeln(x); break;
   default:
}



An alternative idea is to use "__", that is a reserved 
identifier. It's a little longer but I think it's still 
acceptable:


foreach (__; 0 .. 10) { // OK
   foreach (__; 0 .. 20) { // OK
     writeln(__); // syntax error
   }
}

foreach (immutable i, __; items) {...}

t{__, b} = fooAB();

switch (foo) {
   case Foo(x, __, __): writeln(x); break;
   default:
}


Bye,
bearophile