Why do most/all languages not have a multi-loop break function? - loops

Question

I haven't seen any programming language that has a simple function to break out of nested loops. I'm wondering:
Is there something at a low level making this impossible?
Here is an example of what I mean (C#):
while (true)
{
foreach (String s in myStrings)
{
break 2; // This would break out of both the foreach and while
}
}
Just break; would be like break 1;, and take you out of only the innermost loop.
Some languages have messy alternatives like goto, which work but are not as elegant as the above proposed solution.

Answer 1

No there's nothing on a low level that would prevent creating something like what you propose. And you also have a lot of languages implemented in a highlevel language that definitely would allow for this kind of behaviour.
There are however several considerations when designing a language that would talk against this sort of construct, at least there is from my point of view.
The main argument being that it opens up for a very complex structure in something that is probably allready overly complex. Nested loops are inherently hard to follow and figure out what is happening.
If you'd add your construct it could make them even more complex.
Unless you consider a return statement as a sort of break of course :)

Answer 2

Perl does have something very similar to this feature. Instead of the number of nestings, you use a label much like goto.
FOREVER:while (1) {
for my $string (#strings) {
last FOREVER;
}
}
The feature is intended to remove ambiguities when using loop controls in deeply nested loops. Using a label improves readability and it protects you should your level of nesting change. It reduces the amount of knowledge the inner loops have about the outer loops, though they still have knowledge.
The nesting is also non-lexical, it will cross subroutine boundaries. This is where it gets weird and more goto-like.
FOREVER:while (1) {
for my $string (#strings) {
do_something;
}
}
sub do_something {
last FOREVER;
}
This is not considered a good feature for all the reasons #Codor lays out in their answer. This sort of feature encourages very complex logic. You're nearly always better off restructuring deeply nested loops into multiple subroutine calls.
sub forever {
while (1) {
for my $string (#strings) {
return;
}
}
}
What you're asking for is, essentially, a restricted goto. It carries with it most of the same arguments for and against.
while (1) {
for my $string (#strings) {
goto FOREVER;
}
}
FOREVER:print "I have escaped!\n"
The idea of saying "break out of the nth nested loop" is worse than a goto from a structural perspective. It means inner code has intimate knowledge of its surroundings. Should the nesting change, all of the inner loop controls may break. It creates a barrier to refactoring. For example, should you want to perform an extract method refactoring on the inner loop...
while (1) {
twiddle_strings(#strings);
}
sub twiddle_strings {
for my $string (#strings) {
last 2;
}
}
Now the code controlling the outer loop is in a completely different function from the inner loop. What if the outer loop changes?
while (1) {
while(wait_for_lock) {
twiddle_strings(#strings);
}
}
sub twiddle_strings {
for my $string (#strings) {
last 2;
}
}

Answer 3

PHP has it since version 4. And IMHO it's not very good - it's quite easy to abuse it. Especially when you add levels to iterations or remove some or change code logic inside iterations. Code refactoring / optimization usually begins with iterations overview and trying to reduce cycles to conserve CPU usage. During this kind of optimization it's easy to miss a continue level and finding this kind of introduced bug is not an easy task if multiple people are working on a project.
I'd prefer any time goto since it's (usually) much safer. Unless you know exactly what you are doing. Also, goto keeps BASIC in my mind.

Answer 4

Although this is more speculation, there are some arguments both for and against such a possibility.
Pro:
Might be very elegant in some cases.
Con:
Might result in a tempation to write deeply nested loops, which is seen as undesirable by some.
The desired behaviour can be implemented with goto.
The desired behaviour can be implemented with auxiliary variables.
Nested loops can in most cases be refactored to use just one loop.
The desired behaviour can be implemented using exception handling (although, on the other hand, controlling the expected flow of execution is not the primary task of exception handling).
That being said, I consider resposible usage of goto to be legitimate.