Rejection Notice

This PEP is rejected. Seehttps://mail. Python.org/pipermail/ Python -3000/2007-July/008663.html.

Abstract

This PEP proposes support for labels in Python’sbreakand continuestatements. It is inspired by labeledbreakand continuein other languages, and the author’s own infrequent but persistent need for such a feature.

Introduction

Thebreakstatement allows the programmer to terminate a loop early, and thecontinuestatement allows the programmer to move to the next iteration of a loop early. In Python currently,break andcontinuecan apply only to the innermost enclosing loop.

Adding support for labels to thebreakandcontinuestatements is a logical extension to the existing behavior of thebreakand continuestatements. Labeledbreakandcontinuecan improve the readability and flexibility of complex code which uses nested loops.

For brevity’s sake, the examples and discussion in this PEP usually refers to thebreakstatement. However, all of the examples and motivations apply equally to labeledcontinue.

Motivation

If the programmer wishes to move to the next iteration of an outer enclosing loop, or terminate multiple loops at once, he or she has a few less-than elegant options.

Here’s one common way of imitating labeledbreakin Python (For this and future examples,...denotes an arbitrary number of intervening lines of code):

foraina_list:
time_to_break_out_of_a=False
...
forbinb_list:
...
ifcondition_one(a,b):
break
...
ifcondition_two(a,b):
time_to_break_out_of_a=True
break
...
iftime_to_break_out_of_a:
break
...

This requires five lines and an extra variable, time_to_break_out_of_a,to keep track of when to break out of the outer (a) loop. And those five lines are spread across many lines of code, making the control flow difficult to understand.

This technique is also error-prone. A programmer modifying this code might inadvertently put new code after the end of the inner (b) loop but before the test fortime_to_break_out_of_a,instead of after the test. This means that code which should have been skipped by breaking out of the outer loop gets executed incorrectly.

This could also be written with an exception. The programmer would declare a special exception, wrap the inner loop in a try, and catch the exception and break when you see it:

classBreakOutOfALoop(Exception):pass

foraina_list:
...
try:
forbinb_list:
...
ifcondition_one(a,b):
break
...
ifcondition_two(a,b):
raiseBreakOutOfALoop
...
exceptBreakOutOfALoop:
break
...

Again, though; this requires five lines and a new, single-purpose exception class (instead of a new variable), and spreads basic control flow out over many lines. And it breaks out of the inner loop with breakand out of the other loop with an exception, which is inelegant.[1]

This next strategy might be the most elegant solution, assuming condition_two() is inexpensive to compute:

foraina_list:
...
forbinb_list:
...
ifcondition_one(a,b):
break
...
ifcondition_two(a,b):
break
...
ifcondition_two(a,b)
break
...

Breaking twice is still inelegant. This implementation also relies on the fact that the inner (b) loop bleeds b into the outer for loop, which (although explicitly supported) is both surprising to novices, and in my opinion counter-intuitive and poor practice.

The programmer must also still remember to put in both breaks on condition two and not insert code before the second break. A single conceptual action, breaking out of both loops on condition_two(), requires four lines of code at two indentation levels, possibly separated by many intervening lines at the end of the inner (b) loop.

ALOOP: foreach $a (@a_array){
...
BLOOP: foreach $b (@b_array){
...
if (condition_one($a,$b)){
last BLOOP; # same as plain old last;
}
...
if (condition_two($a,$b)){
last ALOOP;
}
...
}
...
}

foreach ($a_array as $a){
....
foreach ($b_array as $b){
....
if (condition_one($a, $b)){
break 1; # same as plain old break
}
....
if (condition_two($a, $b)){
break 2;
}
....
}
...
}

What this PEP is not

This PEP is not a proposal to add GOTO to Python. GOTO allows a programmer to jump to an arbitrary block or line of code, and generally makes control flow more difficult to follow. Although breakandcontinue(with or without support for labels) can be considered a type of GOTO, it is much more restricted. Another Python construct,yield,could also be considered a form of GOTO – an even less restrictive one. The goal of this PEP is to propose an extension to the existing control flow toolsbreakand continue,to make control flow easier to understand, not more difficult.

Labeledbreakandcontinuecannot transfer control to another function or method. They cannot even transfer control to an arbitrary line of code in the current scope. Currently, they can only affect the behavior of a loop, and are quite different and much more restricted than GOTO. This extension allows them to affect any enclosing loop in the current name-space, but it does not change their behavior to that of GOTO.

Specification

Under all of these proposals,breakandcontinueby themselves will continue to behave as they currently do, applying to the innermost loop by default.

foraina_listasa_loop:
...
forbinb_listasb_loop:
...
ifcondition_one(a,b):
breakb_loop# same as plain old break
...
ifcondition_two(a,b):
breaka_loop
...
...

foraina_listlabela_loop:
...
forbinb_listlabelb_loop:
...
ifcondition_one(a,b):
breakb_loop# same as plain old break
...
ifcondition_two(a,b):
breaka_loop
...
...

foraina_list:
...
forbinb_list:
...
ifcondition_one(a,b):
break0# same as plain old break
...
ifcondition_two(a,b):
break1
...
...

foraina_list:
...
forbinb_list:
...
ifcondition_one(a,b):
break# plain old break
...
ifcondition_two(a,b):
breakbreak
...
...

a_iter=iter(a_list)
foraina_iter:
...
b_iter=iter(b_list)
forbinb_iter:
...
ifcondition_one(a,b):
breakb_iter# same as plain old break
...
ifcondition_two(a,b):
breaka_iter
...
...

a_iter=iter(a_list)
foraina_iter:
...
b_iter=iter(b_list)
forbinb_iter:
...
ifcondition_one(a,b):
b_iter.break()# same as plain old break
...
ifcondition_two(a,b):
a_iter.break()
...
...

Implementation

I have never looked at the Python language implementation itself, so I have no idea how difficult this would be to implement. If this PEP is accepted, but no one is available to write the feature, I will try to implement it myself.

Footnotes

Resources

This issue has come up before, although it has never been resolved, to my knowledge.

• labeled breaks,on comp.lang. Python, in the context of do...whileloops
• break LABEL vs. exceptions + PROPOSAL,on Python -list, as compared to using Exceptions for flow control
• Named code blockson Python -list, a suggestion motivated by the desire for labeled break / continue
• mod_ Python bug fixAn example of someone setting a flag inside an inner loop that triggers a continue in the containing loop, to work around the absence of labeled break and continue

Copyright

This document has been placed in the public domain.