🚀 go-pugleaf

Richard Krehbiel (rich@kastle.com) wrote:
: 
: Just last week I found a defective piece of code that avoided a goto
: to leave a doubly-nested loop.  It broke the outer loop by
: synthesizing it's exit condition, but it did it wrong.  I extracted
: both loops into a separate static function, so that the inner loop
: could break both loops with "return".  I was fortunate that these
: loops' use of local variables was limited enough to make the
: extraction viable.  I could have used "goto" but it's bad practice.

The original programmer had probably had 'goto is bad' bashed
into him with such force that he started doing really horrible
hacks like synthsising exit conditions to avoid it. This is
silly.

Why did you make it a separate function? Why not just do a goto?
Call the label something like 'outer_break:'. This would probably
be clearer than calling a new function, and there would be less
chance of accidentally introducing a bug. For example you might
accidentally reference a global variable in the new function that
was hidden by a local in the original function. (That's just an
example - obviously you don't have nasties like global variables
in your code :-)

Why would goto have been bad practice in this case, yet with a
little syntactic sugar you consider the exact same thing a
useful language extension.

One two-level break doesn't make spagetti code.

-- 
It's not so much an afterlife, more a sort of apres-vie.  --DNA
--
Erik Corry ehcorry@inet.uni-c.dk