foreach/else

[lyubomyr-shaydariv]

The following proposal's value may be really low, nothing revolutionary, but sometimes one may need the code like the following:

// bar is an IEnumerable<T>
foreach ( var foo : bar ) {
    Console.WriteLine(foo);
} else {
    Console.WriteLine("no foos in the bar");
}

Just a little syntax sugar.

EDIT

Please note that there would be no a straightforward extension method: foreach might contain break, continue and return.

[Maxwe11]

More obviously

foreach (var foo in bar)
{
    empty { Console.WriteLine("no foos in the bar"); }

    Console.WriteLine(foo);
}

like in #131

[lyubomyr-shaydariv]

@Maxwe11 just curious: why put empty inside the foreach block? Where would you place the Console.WriteLine(foo); then?

[Maxwe11]

@lyubomyr-shaydariv Console.WriteLine(foo); could be placed anywhere inside foreach block.

[lyubomyr-shaydariv]

@Maxwe11 hmm, it does not really look natural to me. It reminds me something like:

if ( foo )
{
    else { Console.WriteLine("bar"); }
    Console.WriteLine("foo");
}

[s-aida]

This and #131 make me wish we had an Each method, like jQuery (aside of possible perf regression).

foos.Each( (foo, index) => { Console.WriteLine(foo); } ).Else( ()=>{ Console.WriteLine("no foo"); } );

[khellang]

This and #131 make me wish we had an Each method, like jQuery (aside of possible perf regression).

That's a quick fix. Just add some extension methods 😄

[Maxwe11]

@lyubomyr-shaydariv putting empty block inside foreach block we emphasize on that it belongs to zero iterations of cycle. Construction loop { } else { } looks like someone forgot if statement. Also it some dissonance with that two equal branches could be executed differently (first branch repeatedly against second branch once).

[AdamSpeight2008]

Instead of 'else' what about 'otherwise'?

foreach( var x in xs )
{
}
otherwise
{
}

[lyubomyr-shaydariv]

@Maxwe11 It shouldn't have a big impact for readability. Suppose the following construction:

if ( fooCollection.Count != 0 ) { // it's easy for collections, but not that convenient for enumerables
   foreach ( var foo : fooCollection ) {
       Console.WriteLine(foo);
   }
} else {
    Console.WriteLine("no foos in bar");
}

This covers what you mentioned for the different execution (the else has the same semantics). Concerning the loop/else I think it just follows the "if/else" and "do/while" style, where the place of else is more of a matter of readability/formatting.

[AdamSpeight2008]

This code doesn't work

   var en = seq.GetEnumerator();
   var o = "";
   if( en.MoveNext() )
   {
       o = en.Current.ToString();
       foreach(var s in en)
       {
           o = o + ", " + s.ToString();
       }
   }

but should it? Since en is an Enumerator.

An OnFirst extension method should return a Tuple<IEnumerator<T>, R> so that the enumerator can be "passed on" to the next method. LINQ extension methods have to be implemented on that return Type.

[RichiCoder1]

Maybe something like:

foreach(var item in items)
{
    // Do stuff...
} empty {
    // Do other stuff...
}

which we be the same as

bool didLoop = false;
var itemsEnumerator = items.GetEnumerator();
while(itemsEnumerator.MoveNext())
{
    var item = items.Current;
    if(!didLoop)
        didLoop = true;
    // Do stuff...
}
if(!didLoop)
{
    // Do other stuff...
}

Edit: @lyubomyr-shaydariv is much smarter about this:

var itemsEnumerator = items.GetEnumerator();
if(itemsEnumerator.MoveNext())
{
    do 
    {
        var item = items.Current;
        // Do stuff...
    } while(itemsEnumerator.MoveNext())
}
else
{
    // Do other stuff...
}

or

if(items.Length > 0)
{
    for(int i = 0; i < items.Length; i++)
    {
        var item = items[i];
        // Do stuff...
    }
}
else
{
    // Do other stuff...
}