Proposal: add syntax for making a loop without included conditions/statements

[WhenJavaAttacks]

Currently, there is no way in C# to specify a "plain" loop without conditionals (while, do…while) or statements (for). My proposal is to add support for such a loop to C#.

Justifications

There are a number of scenarios where being able to declare a "plain" loop such as this could actually be useful, including cases where we could avoid unnecessary additional evaluations of the same conditional statements, or handle more complex logic flows around the conditions when we should exit the loop. Some example cases include:

• when meeting the loop exit condition we also wish to execute other statements before leaving the loop (without having to evaluate the condition again when the while is reached)
• the condition for exiting the loop involves checking multiple conditions, where if that condition is met then we need to fetch some external data to be able to check the next condition (but this external data is not necessary to fetch if the first condition isn't met)
• there are multiple different circumstances with which we would want to exit the loop at those points without having to wait until the beginning or end of the loop block is reached
• cases where the more complex loop exit conditions technically can be reduced to one conditional statement at the beginning/end of the loop but this would result in code that is less clean and less readable than simply having the check in the block of the loop

Of course, there are ways to get this behavior with the existing loops in C# by specifying (true) for while/do…while or a for loop with empty statements (just ;;), but these all are "hack-y" and hurt readability due to the extraneous code and breaking convention with the intended usage of these loops. Being able to simply have a loop with syntax that doesn't require conditional/statement in the first place easily avoids any confusion from these incongruent usages.

Syntax

I am of course open to discussion on what the syntax should be to implement this, but I would propose adding this to C# syntax either as a do loop without a while, or just simply using the word loop. Using while without a condition (as I have seen proposed before) is confusing, since the word while itself implies a condition ("while? while what?"). Using a do without a while makes much more sense semantically and would fit well with established C# naming conventions, although I believe we would still have to require a terminating ; at the end (as a do…while loop already requires anyway) to avoid ambiguity in the event a separate while loop was declared after it. And using just the word loop would also work well as using a different keyword avoids any confusion with existing loops. If there is concern perhaps that loops intended to have an exit condition by design could now lack that, simple checks could be added that a loop or do without a while that lacks any break statement in the body automatically triggers a warning, and then we don't have to worry about an uptick in programmers accidentally writing infinite loops because we introduced a kind of loop that doesn't require exit conditions/statements.

[HaloFour]

See: #6643 and #2475

[yaakov-h]

Currently, there is no way in C# to specify a "plain" loop without conditionals (while, do…while) or statements (for).

There is technically:

using System;

public class C
{
    public void M()
    {
        Loop:        
        Console.WriteLine("Are we there yet?");        
        goto Loop;
    }
}

[Richiban]

While I agree that, if we were building a new language, it might be a good idea to add a loop keyword, I think the benefit is so marginal to C# it's not worth the effort.

Rust has a loop keyword because it enables scenarios that would be otherwise disallowed by the type system (regarding lifetimes, definite analysis, FnOnce etc), little of which applies to C#.

Aside: Rust also allows one to break a value from the loop, which I find pretty cool:

let mut i = 1;
let something = loop {
    i *= 2;
    if i > 100 {
        break i;
    }
};
assert_eq!(something, 128);