Bram Cohen

I think your second example does express "scan for the thing I want, and then do something with it" pretty well. As for the indentation problem, have you considered setting your editor to display tabs as two or three characters wide rather than four?

two words: map & closure

That's one reason why I like Perl - it has more structured solution: the last operator.

CHECK: {
for $eggs ( @spam ) {
for $jello ( @$eggs ) {
if ( $jello is the one I want ) {
last CHECK;
} } }
return; # check failed
}
do stuff with eggs and jello;

P.S. Don't know how to easily format that.

ah,. you are a victim of religious propaganda, too..

The simple fact is that the motto "goto is considered harmful" was propagated by an extremist, mr Djikstra, and in reaction to the previous programming practices, which they labelled as "spagetti code". What came after the war was the "structured programming paradigm", which technically manifested itself in building operators for the creation of subroutines and functions into programming languages.

The fighters of this Reformation, however, did not realize that "goto" itself is sufficient for an elegant minimalistic way of subroutine creation, and that this technique avoids overhead plus restrictions on arguments and return results etc.
Actually, the question of utility of "goto" as a language operator is completely independent of the question of need to structure larger programs - but historically, falsely, they became inseparable. Goto got cursed, and remained one of the strongest taboos of programming: as usual, humanity was saved from itself by forcing unto it the ways to do things, and heretics were damned so strongly that to this very day every bloody author on every book on programming feels obliged to appologize profusely when mentioning the "goto" operator, exactly once in the whole text and not to remember the damn thing afterwards, ever.
The witchhunt continued for decades, I have a university publication from 1994, "researching" (!!) the ways goto can be eliminated from programs - at the expense of creating complicated set of moves totally upturning logic and readability.

In fact, there existed a different position even during time of Religious Wars, much more moderate that that of extremist Djikstra. You might be surprised to learn that one of the moderates' names was Donald Knuth, who published an article advocating the use of the operator when needed. As far as I remember, he even cited examples of proper and even beautiful uses of "goto".

What is even less known, at least in this context, is that Knuth offered his own paradigm in competition to Structured Programming. Many people heard the name of it, but few, amazingly few (considering the simplicity of the approach) know what that term means: Literate Programming.
L.P. is not "a documentation tool" - it is a programming paradigm, that allows structuring without the use of built-in functions/subroutines for human readability only.
L.P. basically is (a) writing programs in pseudocode, whereupon arbitrary phrases in a human language become precise operators of a "meta-language" created at the moment of programming
(b) and a way to provision for programming in the order of thinking, i.e. not as machine instructions demand, but the way humans logically do it.

Having hit upon the idea and tried it, Knuth wrote of the feeling of relief from the "structured programming" practices and proclaimed that L.P. was the true way to program. Regrettably, not that many noticed.

After Knuth's first Web tools for L.P. others were created, simplifying the concept and detangling ot both from the TeX and interdependence with a particular programming language, the most accessible one is "noweb" by Ramsey.

To return to the question of "goto" and finish with it, let me tell also that even enemies of "goto" during those Wars admitted that it works faster (at least for C implementations) than built-in subroutines/functions, the latter besides restricting the programmer's thinking involve unneccessary overhead.
The use of built-in functions is justified for recursion, for instance, when implicit shuffling behind the scenes is used for a good purpose, but can be avoided when subdivision is created simply not to lose the thread when thinking.

And the idea of structuring the program into precise equivalent of subroutines/functions with goto statements (which produces a clear, readable layout as well) is very, very true, while being totally unknown to the programming masses today.

So o hell with extremist Djikstra.
As far as I am concerned, Goto is considered helpful

That one is nice. Also, for the not-so-bad case, you may want to inverse the nested condition to make it continue if it doesn't match what you're looking for. So

for i in range(5):
    if i == 3:
        do(i)
        things(i)
        and(i)
        some(i)
        more(i)

becomes

for i in range(3):
    if i != 3:
        continue
    do(i)
    things(i)
    and(i)
    some(i)
    more(i)

It's probably the best variant, for some reason it didn't occur to me until I was writing the post though.