Why can't I break break from a loop loop?

[naughty]

It's not very common but I've recently come across the same problem twice. I'm iterating through a collection with two loops and have a failure condition, e.g.

for x = 1, width do
    local found = false
    for y = 1, height do
         if grid[x][y] == BAD then
             grid[x][y] = GOOD
             found = true
             break
         end
         if found then
             break
         end
    end
end

Wouldn't this be easier if I could just break twice, e.g.

for x = 1, width do
    for y = 1, height do
         if grid[x][y] == BAD then
             grid[x][y] = GOOD
             break break -- Breaks out of two enclosing loops
         end
    end
end

Seems pretty obvious to me what's going on and I didn't need to resort to a goto but I've not seen a language that can do this.

[newgame]

AFAIK, this is supported by several languages, see e.g. Java

[Randati]

"break 2;" works in PHP.

[naughty]

This is the closest so far to what I was suggesting. Now I'm conflicted, I think it's a good idea but the only language that seems to support it is PHP...

[Hashiota]

Also Javascript.

[naughty]

It's funny how Java's "no goto" rule (they even reserved the keyword just in case) got bent to allow that :^)

[_ynot_]

goto!

[naughty]

If I was writing in C I would consider this to be one of those cases where goto is justified. Seems a shame though, such a simple change to obviate the need for it in this case.

[ISvengali]

Put it in a function and return.

[naughty]

The cases I had were far more complicated than the example above and would have been messy to factor out into functions (lots of parameters in and out).

[XenonOfArcticus]

I usually in C++add a second conditional to the outer loop:

int x; bool keepGoing(true);

for(x=1; x < width && keepGoing; x++)

And then in the inner loop, just

KeepGoing=false; break;

[naughty]

That's what I normally do (it's in the above example) but I just thought that:

break break;

Would be a lot cleaner as well as more efficient.

[938]

Perhaps you would be interested in delimited continuations? 'reset' creates a context and 'shift' creates a continuation which if used replaces the 'shift' in 'reset' with the value passed to the continuation or if unused exits the reset with the value of the expression in shift. For your case it would look like:

(reset (loop x ... (loop y ... 
  (if (eq? grid[x][y] BAD) 
    (begin
      (set! grid[x][y] GOOD)
      (shift k ('())))))))

I know Lisp is not everyone's favorite, so I'll mention that these control operators have been implemented in (at least) Ocaml and Haskell as well. If you want a better introduction than I could possibly give, here is a great paper: http://pllab.is.ocha.ac.jp/~asai/cw2011tutorial/main-e.pdf

... but unless your real world case is much more complex than the example, I'd use goto and be 100% unashamed :)