Flow-control structures
You are encouraged to solve this task according to the task description, using any language you may know.
These are examples of control structures. You may also be interested in:
In this task, we document common flow-control structures. One common example of a flow-control structure is the goto construct. Note that Conditional Structures and Loop Structures have their own articles/categories.
Ada
goto
<lang ada><<Top>>
Put_Line("Hello, World");
goto Top;</lang>
exit
Exit is used to break out of loops. Exit can be used with a label to break out of an inner loop to an outer loop and its enclosing outer loop <lang ada>Outer:
loop
-- do something
loop
-- do something else
exit Outer; -- exits both the inner and outer loops
end loop;
end loop;</lang>
asynchronous transfer of control
A sequence of operation can be aborted with an asynchronous transfer of control to an alternative: <lang ada>select
delay 10.0;
Put_Line ("Cannot finish this in 10s");
then abort
-- do some lengthy calculation ...
end select;</lang> The alternative can be a delay statement or else an entry point call followed by a sequence of operations. The statement blocks at the delay or entry call and executes the sequence of the operation introduced by then abort. If blocking is lifted before completion of the sequence, the sequence is aborted and the control is transferred there.
ALGOL 68
See also Exceptions to see how ALGOL 68 handles transput events.
One common use of a label in ALGOL 68 is to break out of nested loops.
<lang algol68>(
FOR j TO 1000 DO
FOR i TO j-1 DO
IF random > 0.999 THEN
printf(($"Exited when: i="g(0)", j="g(0)l$,i,j));
done
FI
# etc. #
OD
OD;
done: EMPTY
);</lang>
Multi way jump using labels and EXIT to return result
<lang algol68>STRING medal = (
[]PROC VOID award = (gold,silver,bronze);
award[ 1 + ENTIER (random*3)];
gold: "Gold" EXIT silver: "Silver" EXIT bronze: "Bronze"
);
print(("Medal awarded: ",medal, new line));</lang>
Another use is to implement finite state machines
<lang algol68>STRING final state = (
INT condition;
PROC do something = VOID: condition := 1 + ENTIER (3 * random);
state1:
do something;
CASE condition IN
state 1, state 2
OUT
state n
ESAC
EXIT
state 2:
"State Two"
EXIT
state n:
"State N"
); print(("Final state: ",final state, new line));</lang>
ALGOL 68G implements a Refinement Preprocessor to aid with top down code development
<lang algol68># example from: http://www.xs4all.nl/~jmvdveer/algol.html - GPL # determine first generation; WHILE can represent next generation DO calculate next generation;
print next generation
OD.
determine first generation:
INT previous := 1, current := 3.
can represent next generation:
current <= max int - previous.
calculate next generation:
INT new = current + previous; previous := current; current := new.
print next generation:
printf (($lz","3z","3z","2z-d$, current,
$xz","3z","3z","2z-d$, previous,
$xd.n(real width - 1)d$, current / previous)).</lang>
Sample output:
Exited when: i=13, j=53
Medal awarded: Gold
Final state: State Two
4 3 1.33333333333333
7 4 1.75000000000000
11 7 1.57142857142857
etc...
AutoHotkey
<lang AutoHotkey>MsgBox, calling Label1 Gosub, Label1 MsgBox, Label1 subroutine finished Goto Label2 MsgBox, calling Label2 ; this part is never reached Return
Label1:
MsgBox, Label1
Return
Label2:
MsgBox, Label2 will not return to calling routine
Return</lang>
AWK
Awk has break and continue for loop control, as in C. <lang awk>$ awk 'BEGIN{for(i=1;;i++){if(i%2)continue; if(i>=10)break; print i}}' 2 4 6 8</lang>
C
goto
One common use of goto in C is to break out of nested loops. <lang c>int main() {
int i,j;
for (j=1; j<1000; j++) {
for (i=0; i<j, i++) {
if (exit_early())
goto out;
/* etc. */
}
}
out:
return 0;
}</lang>
C++
goto
<lang cpp>#include <iostream>
int main() {
LOOP: std::cout << "Hello, World!\n"; goto LOOP;
}</lang>
Note that "goto" may also be used in conjunction with other forms of branching.
Exceptions
Exceptions are a way to give control back to a direct or indirect caller in case of an error. Note that throwing exceptions is usually very expensive, therefore they generally should only be used for exceptional situations. <lang cpp>#include <iostream>
- include <ostream>
void foo() {
std::cout << "Going to throw an exception.\n"; throw 7; // almost any object can be thrown, including ints std::throw << "This output will never execute.\n";
}
void bar() {
std::cout << "Going to call foo().\n"; foo(); std::cout << "This will be skipped by the exception coming from foo.\n";
}
void baz() {
try // everything thrown from inside the following code block
{ // will be covered by the following catch clauses
std::cout << "Going to call bar().\n";
bar();
std::cout << "This will be skipped by the exception coming from foo.\n";
}
catch(...) // a simple catch-all, but doesn't give access to the thrown exception
{
std::cout << "An exception occured. I'll just throw it on.\n";
throw; // without an argument, the caught exception is re-thrown
}
std::cout << "This will not be executed due to the re-throw in the catch block\n";
}
void foobar() {
try
{
baz();
}
catch(char const* s)
{
std::cout << "If foo had thrown a char const*, this code would be executed.\n";
std::cout << "In that case, the thrown char const* would read " << s << ".\n";
}
catch(int i)
{
std::cout << "Caught an int, with value " << i << " (should be 7).\n";
std::cout << "Not rethrowing the int.\n";
}
catch(...)
{
std::cout << "This catch-all doesn't get invoked because the catch(int) above\n"
<< "already took care of the exception (even if it had rethrown the\n"
<< "exception, this catch-all would not be invoked, because it's\n"
<< "only invoked for exceptions coming from the try block.\n";
}
std::cout << "This will be executed, since the exception was handled above, and not rethrown.\n";
}
int main() {
try
{
foobar();
}
catch(...)
{
std::cout << "The main function never sees the exception, because it's completely handled\n"
<< "inside foobar(). Thus this catch-all block never gets invoked.\n";
}
}</lang>
D
goto
<lang d>label1: writeln ("i'm in your infinite loop"); goto label1;</lang>
Exceptions
D supports standard try/catch/finally mechanisms: <lang d>void main (char[][] args) { try { if (args[1] == "throw") throw new Exception ("message"); } catch (DerivedException ex) { // we never threw a DerivedException, so this block is never called writefln ("caught derived exception %s", ex.toString); } catch (Exception ex) { writefln ("caught exception: %s", ex.toString); } catch (Object ex) { // Throwing Objects is allowed but discouraged. writefln ("caught object: %s", ex.toString); } finally { writeln ("finished (exception or none)"); } }</lang>
Scope guards
In a complex function, you might need to do cleanup in case of an exception, but it gets out of hand if there are many initialization steps that could fail. Scope guards offer a simplified syntax for try/finally.
There are three scopes you can listen for: exit, which is called unconditionally; failure, which is called if you leave the function via an exception; and success, which is called if you return from the function normally. A statement inside a scope block is only executed if execution reaches the scope block.
For instance: <lang d>void main (char[][] args) { scope (exit) writeln ("gone"); if (args[1] == "throw") throw new Exception ("message"); scope (exit) writeln ("gone, but we passed the first chance to throw an exception"); }</lang>
If the exception is thrown, then the only text that is written to the screen is "gone". If no exception is thrown, both calls to writeln occur.
scope (failure) and scope (success) work similarly.
E
E does not have goto. The only primitive flow control construct which is not a loop, conditional, or exception is escape, or ejectors.
The basic syntax is
escape ej {
...body...
}
Within body variable ej then contains a one-argument function (an ejector) which, if called, immediately returns the provided value from the escape block.
This is a limited form of continuation (it cannot be used after the escape block exits).
Loop break, loop continue, and return-from-middle-of-function are all defined in terms of this basic construct.
Forth
CATCH-THROW
Some Forth implementations have goto, but not the standard. It does have an exception mechanism. <lang forth>: checked-array
CREATE ( size -- ) DUP , CELLS ALLOT
DOES> ( i -- a+i )
2DUP @ 0 SWAP WITHIN IF
SWAP 1+ CELLS +
ELSE
1 THROW
THEN ;
8 checked-array myarray
- safe-access ( i -- a[i] )
['] myarray CATCH 1 = IF ." Out of bounds!" 0 THEN ;</lang>
Haskell
In the context of normal, functional-style code, there are no flow-control statements, because explicit flow control is imperative. A monad may offer flow control; what kinds are available depends on the monad. For example, the ExitT monad transformer lets you use the exitWith function to jump out a block of statements at will.
<lang haskell>import Control.Monad import Control.Monad.Trans import Control.Monad.Exit
main = do
runExitTMaybe $ do
forM_ [1..5] $ \x -> do
forM_ [1..5] $ \y -> do
lift $ print (x, y)
when (x == 3 && y == 2) $
exitWith ()
putStrLn "Done."</lang>
HicEst
More on HicEst's ALARM function <lang hicest>1 GOTO 2 ! branch to label
2 READ(FIle=name, IOStat=ios, ERror=3) something ! on error branch to label 3
3 ALARM(delay, n) ! n=2...9 simulate F2 to F9 keys: call asynchronously "Alarm"-SUBROUTINES F2...F9 with a delay
4 ALARM( 1 ) ! lets HicEst wait at this statement for any keyboard or mouse event
5 SYSTEM(WAIT=1000) ! msec
6 XEQ('CALL my_subroutine', *7) ! executes command string, on error branch to label 7
7 y = EXP(1E100, *8) ! on error branch to label 8
8 y = LOG( 0 , *9) ! on error branch to label 9
9 ALARM( 999 ) ! quit HicEst immediately</lang>
Icon
Prelude about Goal-Directed Evaluation and Generators
A central feature of Icon and Unicon is what is known as Goal-Directed Evaluation, and the intimately related concept of Generators. Without trying to be a tutorial, the idea is that expressions can yield more than one result (Generators) and if a further part of the expression results in failure, the earlier Generators will be driven to yield more results. The effect is not unlike the backtracking found in Prolog or Regular Expressions, however the feature is built into the very core of the language. Prolog programmers will find it very familiar but of course with differences because Icon and Unicon do not use the functional language pattern matching technique of Prolog.
To cut a long story short, every expression and statement can fail, or generate one or more results that can be consumed or applied in further parts of the statement. There are also a few keyword statements which force the generation of all possible outcomes for a statement or expression.
Another way of looking at it is to understand that every expression can yield a result sequence that can be empty; any code using this expression may choose to ask for more results, gather them into a container or aggregate, or choose to use one value and then move on without asking for all possible results.
goto
Does not exist in the Icon or Unicon language.
next
Restarts the enclosing loop. The conditional on the loop is evaluated as normal.
break expr
Default value of expr is the null value &null. This operator breaks out of the enclosing loop, yielding the expression as the result of the loop. Normally loops yield a failure ie no result, so you can write code like this: <lang icon>
if x := every i := 1 to *container do { # * is the 'length' operator
if container[i] ~== y then
write("item ", i, " is not interesting")
else
break a
} then
write("found item ", x)
else
write("did not find an item")
</lang> The expression given to break can be another break, which effectively lets you break out of two levels of loop. Finally, the expression given to break can be the next command; for example <lang icon>
break break next
</lang> breaks out of two levels of loop and re-enters the top of the third-level enclosing loop.
return expr
Default value of expr is &null. Apart from the usual meaning of return, if the expr value fails, then the procedure actually fails too, ie does not yield a value. See description of fail keyword. If the expr is capable of yielding more than one result, only the first result is asked for and used.
fail
Causes the the enclosing procedure to terminate without returning value. This is different from returning void or a null value that many other languages do when the code does not return an actual value. For example, in <lang icon>
x := ftn()
</lang> The value of x will not be replaced if ftn() issues the fail command. If ftn fails, then Goal-Directed Evaluation will also fail the assignment, therefore x is not assigned a new value. If the flow of control through a procedure falls off the end, the procedure implicitly fails.
suspend expr
Default value of expr is &null. Any procedure containing the suspend command will yield a value to the calling code. However the procedure remains in a state of suspended animation ready to be reactivated if the calling code demands another result due to Goal Directed Evaluation. Note that this capability is built directly into the runtime rather than being an artifically constructed behaviour provided by Python or C#'s use of the 'yield' keyword. Every and all expressions may suspend or be involved in a suspending expression without any effort. Behaviourally much closer to Prolog which also supports backtracking as a core part of the language. If the expr is capable of yielding more than one result, then supend (if driven) will progressively yield all of those values.
A procedure can contain several uses of suspend and it's quite reasonable for the procedure to execute many of them in any chosen order.
stop(expr)
Terminate program with prejudice.
error trapping
The keyword &error is normally zero, but if set to a positive value, this sets the number of fatal errors that are tolerated and converted to expression failure; the value of &error is decremented if this happens. Therefore the now-common TRY-CATCH behaviour can be written as: <lang icon>
&error := 1
mayErrorOut()
if &error == 1 then
&error := 0 # clear the trap
else {
# deal with the fault
handleError(&errornumber, &errortext, &errorvalue) # keyword values containing facts about the failure
}
</lang> Various idiomatic simplifications can be applied depending on your needs.
error throwing
Errors can be thrown using the function <lang icon>
runerr(errnumber, errorvalue) # choose an error number and supply the offending value
</lang>
IDL
goto
<lang idl>test: ..some code here goto, test</lang>
(This is almost never used)
on_error
<lang idl>on_error, test</lang>
(This resumes at the label test if an error is encountered)
on_ioerror
<lang idl>on_ioerror, test</lang>
(Same as on_error, but for EOFs and read-errors and such)
break
<lang idl>break</lang>
immediately terminates the innermost current loop (or if or case etc)
continue
<lang idl>continue</lang>
immediately starts the next iteration of the current innermost loop
J
Control structures should usually [but not always] be avoided in J. J's primitives already provide iteration and selection.
For example, here's an example of a program which loops over a sequence of integers, multiplying them by two (the result is displayed on the following line): <lang j> 2 * 1 2 3 2 4 6</lang>
That said, J's control structures are documented at http://www.jsoftware.com/help/dictionary/ctrl.htm So, if you want to perform this same operation using a while loop, or a goto, you can do so. It's just... probably not a good idea.
Java
"goto" is a reserved keyword in Java; but you cannot use it. There are currently no goto statements.
JavaScript
returnfrom a function ([1])- loop control with
break [label]([2]) andcontinue [label]([3]) - exceptions with
throw([4]) andtry ... catch ... finally ...([5])
OCaml
An OCaml user can simulate flow control using exceptions:
<lang ocaml>exception Found of int
let () =
(* search the first number in a list greater than 50 *) try let nums = [36; 23; 44; 51; 28; 63; 17] in List.iter (fun v -> if v > 50 then raise(Found v)) nums; print_endline "nothing found" with Found res -> Printf.printf "found %d\n" res</lang>
Oz
Exception handling is documented in other tasks: Exceptions#Oz, Exceptions Through Nested Calls#Oz.
The case statement can be used for Pattern Matching, but also like a switch statement in C:
<lang oz>case {OS.rand} mod 3
of 0 then {Foo}
[] 1 then {Bar}
[] 2 then {Buzz}
end</lang>
The Lisp-influenced for-loop is very powerful and convenient to use.
As a constraint programming language, Oz has a number of flow control structures which target logic programming. They are typically used to implement new constraint search engines. However, it is also possible to use them for general logic programming.
or: speculatively executes a number of alternative conditions and blocks until at most one alternative remains valid. Then either fails or commits to the remaining alternative if there is one.
cond: evaluates a number of conditions in parallel (or in undefined order) and commits to the first alternative that succeeds.
dis: depreciated
choice: creates a non-deterministic choice point. In other words, the statement provisionally chooses an alternatives. If the choice turns out to be wrong or if additional solutions to a puzzle are searched, another alternative is chosen.
As an example for choice, a simple, but stupid way to solve the equation 2*X=18. We assume that the solution is somewhere in the interval 8-10, but we do not quite know what exactly it is.
<lang oz>declare
proc {Stupid X}
choice
X = 8
{System.showInfo "choosing 8"}
[] X = 9
{System.showInfo "choosing 9"}
[] X = 10
{System.showInfo "choosing 10"}
end
2 * X = 18
end
in
{Show {SearchOne Stupid}}</lang>
Output:
choosing 8 choosing 9 [9]
Perl
goto
Goto is typically looked down upon by most Perl programmers
<lang perl>FORK:
- some code
goto FORK;</lang>
PicoLisp
As this task asks for the documentation of common flow control structures, we refer here to the online documentation for more complete descriptions and examples.
Relevant functions are:
fork
fork creates a child process
task
task installs a background task consisting of an environment and a list of executable expressions
alarm
alarm schedules a timer, which runs a given list of executable expressions when it expires
abort
abort runs a given list of executable expressions, and aborts processing it if it takes longer than a given time
quit
quit immediately stops all execution and returns to the top level read-eval-print loop, optionally signaling an error
wait
wait delays current processing (optionally to a maximal time) until an optionally given condition evaluates to non-NIL
sync
sync synchronizes with other processes of the same family
protect
protect delays the processing of signals while a given list of executable expressions is executed
catch
catch prepares for receiving a 'throw' while running a given list of executable expressions
throw
throw causes a non-local jump to a specified 'catch' environment
bye
bye exits the interpreter
finally
finally specifies a list of executable expressions, to be run when current processing is done, even if a 'throw' or 'bye' was executed, or an error occurred.
PL/I
<lang PL/I> LEAVE
The LEAVE statement terminates execution of a loop. Execution resumes at the next statement after the loop.
ITERATE
The ITERATE statement causes the next iteration of the loop to commence. Any statements between ITERATE and the end of the loop are not executed.
STOP
Terminates execution of either a task or the entire program.
SIGNAL FINISH
Terminates execution of a program in a nice way.
SIGNAL statement
SIGNAL <condition> raises the named condition. The condition may be one of the hardware or software conditions such as OVERFLOW, UNDERFLOW, ZERODIVIDE, SUBSCRIPTRANGE, STRINGRANGE, etc, or a user-defined condition.
CALL
The CALL statement causes control to transfer to the named subroutine.
SELECT
The SELECT statement permits the execution of just one of a list of statements (or groups of statements). It is sort of like a computed GOTO.
GO TO
The GO TO statement causes control to be transferred to the named statement. It can also be used to transfer control to any one of an array of labelled statements. (This form is superseded by SELECT, above.)
</lang>
Pop11
quitloop
quitloop with argument exits from nested loops:
<lang pop11>while condition1 do
while condition2 do
if condition3 then
quitloop(2);
endif;
endwhile;
endwhile;</lang>
above quitloop(2) exits from both loops.
goto
goto l transfers control to the label l. goto may be used to exit from nested loops:
<lang pop11>while condition1 do
while condition2 do
if condition3 then
goto l;
endif;
endwhile;
endwhile; l:;</lang>
Another use is to implement finite state machines:
<lang pop11>state1:
DO_SOMETHING();
if condition1 then
goto state1;
elseif condition2 then
goto state2;
....
else
goto stateN;
endif;
state2:
....
... ... stateN:
....</lang>
Pop11 goto is a nonlocal one, so "jump out" from a chain of procedure calls:
<lang pop11>define outer();
define inner(n);
if n = 0 then
goto final;
endif;
inner(n - 1);
enddefine;
inner(5);
final:;
enddefine;</lang>
This is useful to exit early from successful recursive search, and for exception handling.
go_on
go_on is a multiway jump
<lang pop11>go_on expression to lab1, lab2, ..., labN else elselab ;</lang>
If expression has value K the above will jump to label labK, if expression is not an integer, or if it outside range from 1 to N, then control passes to label elselab. The else part may be omitted (then out of range values of expression cause an exception).
There is a more structured variant of go_on:
go_on expression to lab :
lab 1 : statement1; lab 2 : statement2; ....
endgo_on;
where lab is a prefix chosen by the user.
return
return ends execution of current function. In simplest form it is just:
<lang pop11>return;</lang>
but it is also possible to specify one or more return values:
<lang pop11>return(val1, val2, val3);</lang>
chain
chain has effect of "tail call" but is not necessarily in tail position. More precisely inside proc1.
<lang pop11>chain proc2(x1, x2, x3);</lang>
finishes execution of proc1 and transfers control to the proc2 passing it x1, x2, and x3 as arguments. On return from proc2 control passes to caller of proc1.
Remark: Pop11 does not perform "tail call optimization", one has to explicitly use chain.
PureBasic
goto
Transfers control to the label referenced. It is not a safe way to exit loops. <lang PureBasic>If OpenConsole()
top:
i = i + 1
PrintN("Hello world.")
If i < 10
Goto top
EndIf
Print(#CRLF$ + #CRLF$ + "Press ENTER to exit")
Input()
CloseConsole()
EndIf </lang>
Python
Loops
Python supports break and continue to exit from a loop early or short circuit the rest of a loop's body and "continue" on to the next loop iteration. <lang python># Search for an odd factor of a using brute force: for i in range(n):
if (n%2) == 0:
continue
if (n%i) == 0:
result = i
break
else:
result = None print "No odd factors found"</lang>
In addition, as shown in the foregoing example, Python loops support an else: suite which can be used to handle cases when the loop was intended to search for something, where the code would break out of the loop upon finding its target. In that situation the else: suite can be used to handle the failure. (In most other languages one is forced to use a "sentinel value" or a special flag variable ... typically set to "False" before the loop and conditionally set to "True" within the loop to handle situations for which the Python else: on loops is intended).
Exceptions
A Python exception is simply any subclass of the built-in BaseException class, or any of its descendents. User defined exception classes are normally descendents of the Exception class (which is, itself, a subclass of BaseException). To "throw" any exception (user defined or otherwise) one uses the raise statement. To capture exceptions one must enclose the code in a try: ... except...: block. Any exception listed in an except block will catch all subclasses of that exception. For example ZeroDivisionError is derived from ArithmeticError. Thus an exception clause for ArithmeticError would catch a ZeroDivisionError (or any other ArithmeticError).
As a consequence of this one must arrange the order of exception clauses such that the more specific exceptions are listed (caught) before their more general base exceptions. Only the first matching exception clause will be executed. An except clause which lists no exceptions will catch all possible exceptions. (This is usually considered to be very poor programming practice because it can hide unintended coding errors).
An exception can be re-raised by simply calling the raise statement without any arguments (from within any exception handler). Thus a function can catch an exception, attempt to deal with it, then, if necessary, throw it it back to the next layer out in a given call stack. Uncaught exceptions will be handled by the interpreter by terminating the program and printing an error message and stack trace.
A custom Exception class is normally declared with the pass statement as no methods of the parent class are over-ridden, no additional functionality is defined and no attributes need be set. Example:
<lang python>class MyException(Exception): pass</lang>
One normally would choose the most similar existing class. For example if MyException was going to be raised for some situation involving an invalid value it might be better to make it a subclass of ValueError; if it was somehow related to issues with inappropriate objects being passed around then one might make it a subclass of TypeError.
In large projects it's common to create an custom application base exception and to have all or most custom exceptions within that application or framework derive therefrom.
To create a "virtual base class" (one which is not intended to be directly instantiated, but exists solely to provide an inheritance to it's derived classes) one normally defines the requisite methods to raise "NotImplementedError" like so:
<lang python>class MyVirtual(object):
def __init__(self):
raise NotImplementedError</lang>
It then becomes necessary for any descendants of this class to over-ride the __init__() method. Any attempt to instantiate a "MyVirtual" object directly will raise an exception.
Case 1 - Try, Except
<lang python>try:
temp = 0/0
- 'except' catches any errors that may have been raised between the code of 'try' and 'except'
except: # Note: catch all handler ... NOT RECOMMENDED
print "An error occurred."
- Output : "An error occurred"</lang>
Case 2 - Try, Except
<lang python>try:
temp = 0/0
- here, 'except' catches a specific type of error raised within the try block.
except ZeroDivisionError:
print "You've divided by zero!"
- Output : "You've divided by zero!"</lang>
Case 3 - Try, Except, Finally
<lang python>try:
temp = 0/0
except:
print "An error occurred."
- here, 'finally' executes when the try - except block ends, regardless of whether an error was raised or not
- useful in areas such as closing opened file streams in the try block whether they were successfully opened or not
finally:
print "End of 'try' block..."
- Output :
- An error occurred
- End of 'try' block...</lang>
Note: Prior to version 2.5 a try: statement could contain either series of except: clauses or a finally: clause but not both. It was thus necessary to nest the exception handling in an enclosing try:...finally: loop like so:
<lang python>try:
try:
pass
except (MyException1, MyOtherException):
pass
except SomeOtherException:
finally:
do_some_cleanup() # run in any case, whether any exceptions were thrown or not</lang>
Case 4 - Try, Except, Else
<lang python>try:
temp = 1/1 # not a division by zero error
except ZeroDivisionError: # so... it is not caught
print "You've divided by zero."
- here, 'else' executes when no exceptions are caught...
else:
print "No apparent error occurred."
- Output :
- No apparent error occurred.</lang>
Case 5 - Try, Except, break, continue
<lang python>i = 0 while 1: # infinite loop
try:
temp2 = 0/i # will raise a ZeroDivisionError first.
temp = math.sqrt(i)
break # 'break' will break out of the while loop
except ValueError: #
print "Imaginary Number! Breaking out of loop"
break # 'break' out of while loop
except ZeroDivisionError:
print "You've divided by zero. Decrementing i and continuing..."
i-=1 # we decrement i.
# we 'continue', everything within the try - except block will be executed again,
# this time however, ZeroDivisionError would not be raised again.
continue # Note that removing it, replacing it with 'pass' would perform the equivalent
# see below for a better example
- Output :
- You've divided by zero. Decrementing i and continuing...
- Imaginary Number! Breaking out of loop</lang>
Case 6 - Creating your own custom exceptions, raise
<lang python># Let's call our custom error "StupidError"; it inherits from the Exception class
class StupidError(Exception): pass
- Try it out.
try:
raise StupidError("Segfault") # here, we manually 'raise' the error within the try block
except StupidError, details: # 'details' is the StupidError object we create in the try block.
print 'Something stupid occurred:', details # so we access the value we had stored for it...
- Output :
- Something stupid occurred: Segfault</lang>
Case 7 - continue, else in "for" loop
<lang python> i = 101
for i in range(4): # loop 4 times
print "I will always be seen."
if (i % 2) == 0:
continue # continue goes back to the loop beginning for a new iteration.
print "I'll only be seen every other time."
else:
print "Loop done"
# Output:
# I will always be seen.
# I will always be seen.
# I'll only be seen every other time.
# I will always be seen.
# I will always be seen.
# I'll only be seen every other time.
# Loop done
if(__name__ == "__main__"):
main()</lang>
The "with" statement
See [PEP 0343, The "with" statement]
<lang python>class Quitting(Exception): pass max = 10 with open("some_file") as myfile:
exit_counter = 0
for line in myfile:
exit_counter += 1
if exit_counter > max:
raise Quitting
print line,</lang>
The with statement allows classes to encapsulate "final" (clean-up) code which will automatically be executed regardless of exceptions that occur when working "with" these objects. Thus, for the foregoing example, the file will be closed regardless of whether it's more than 10 lines long. Many built-in and standard library classes have "context managers" which facilitate their use in with: code. In addition it's possible to define special __enter__() and __exit__() methods in one's own classes which will be implicitly called by the interpreter when an object is used within a with: statement.
Use cases for with: enabled objects include automated/guaranteed closing of files, release of threading lock objects, commit or rollback of database transactions, and save/restore of any desired state (such as terminal settings when using the curses module, the precision settings when using the Decimal module, or even saving and restoring sys.stdout for temporary redirection). It is a feature that seems to be unique to Python.
Yield expressions
See [PEP 0342, Coroutines via Enhanced Generators]
>>> value = 1 >>> echo = lambda: (yield value) >>> for i in echo(): ... print i ... 1
REBOL
<lang REBOL>REBOL [ Title: "Flow Control" Author: oofoe Date: 2009-12-05 URL: http://rosettacode.org/wiki/Flow_Control_Structures ]
- return -- Return early from function (normally, functions return
- result of last evaluation).
hatefive: func [ "Prints value unless it's the number 5." value "Value to print." ][ if value = 5 [return "I hate five!"] print value ]
print "Function hatefive, with various values:" hatefive 99 hatefive 13 hatefive 5 hatefive 3
- break -- Break out of current loop.
print [crlf "Loop to 10, but break out at five:"] repeat i 10 [ if i = 5 [break] print i ]
- catch/throw -- throw breaks out of a code block to enclosing catch.
print [crlf "Start to print two lines, but throw out after the first:"] catch [ print "First" throw "I'm done!" print "Second" ]
- Using named catch blocks, you can select which catcher you want when throwing.
print [crlf "Throw from inner code block, caught by outer:"] catch/name [ print "Outer catch block." catch/name [ print "Inner catch block." throw/name "I'm done!" 'Johnson print "We never get here." ] 'Clemens print "We never get here, either." ] 'Johnson
- try
div: func [ "Divide first number by second." a b /local r "Result" ][ if error? try [r: a / b] [r: "Error!"] r ; Functions return last value evaluated. ]
print [crlf "Report error on bad division:"] print div 10 4 print div 10 2 print div 10 1 print div 10 0</lang>
Ruby
return
Return from the currently executing method to the caller.
loop control
Ruby's loop control statements are: break, next, redo and retry. Break and next are obvious. Redo and retry both restart the current loop iteration, but retry first reevaluates the condition.
They can control while, until, for loops and iterators.
exceptions
Use raise to throw an exception. You catch exceptions in the rescue clause of a begin...end block.
<lang ruby>begin
# some code that may raise an exception
rescue ExceptionClassA => a
# handle code
rescue ExceptionClassB, ExceptionClassC => b_or_c
# handle ...
rescue
# handle all other exceptions
else
# when no exception occurred, execute this code
ensure
# execute this code always
end</lang> There is also a rescue modifier (example from the Pickaxe book): <lang ruby>values = ["1", "2.3", /pattern/] result = values.map {|v| Integer(v) rescue Float(v) rescue String(v)}
- => [1, 2.3, "(?-mix:pattern)"]</lang>
catch and throw
break will only break out of a single level of loop. You can surround code in a catch block, and within the block you can throw a string or symbol to jump out to the end of the catch block (Ruby's GOTO, I suppose):
<lang ruby>def some_method
# ... if some_condition throw :get_me_out_of_here end # ...
end
catch :get_me_out_of_here do
for ...
for ...
some_method
end
end
end
puts "continuing after catching the throw"</lang>
yield
yield passes control from the currently executing method to its code block.
Tcl
after
The after facility can be used to execute some code at some future time asynchronously, like this
<lang tcl>after 1000 {myroutine x}</lang>
which will call "myroutine" with parameter "x" 1000ms from 'now'; no matter what other code might be running at the time (i.e. "after"; schedules the execution, then returns and continues program flow with the following code).
The scheduled task can be removed from the scheduler for example with
<lang tcl>after cancel myroutine</lang>
(other ways are possible).
The correct way to schedule some regularly recurring task in TCL is to incorporate a self-scheduling at the end of the routine. For example the following will produce a clock whose display is updated once a second:
<lang tcl>package require Tk proc update {} {
.clockface configure -text [clock format [clock seconds]] after 1000 update ; # call yourself in a second
}
- now just create the 'clockface' and call ;update' once:
pack [label .clockface] update</lang>
loop control
Tcl has the break command to abort the current loop (for/foreach/while) and the continue command to skip to the next loop iteration.
exception
Tcl's catch command can be used to provide a basic exception-handling mechanism:
<lang tcl>if {[catch { ... code that might give error ... } result]} {
puts "Error was $result"
} else {
... process $result ...
}</lang> Tcl 8.6 also has a try…trap…finally structure for more complex exception handling. <lang tcl>try {
# Just a silly example... set f [open $filename] expr 1/0 string length [read $f]
} trap {ARITH DIVZERO} {} {
puts "divided by zero"
} finally {
close $f
}</lang>
custom control structures
A novel aspect of Tcl is that it's relatively easy to create new control structures (more detail at http://wiki.tcl.tk/685). For example, this example defines a command to perform some operation for each line of an input file: <lang tcl>proc forfilelines {linevar filename code} {
upvar $linevar line ; # connect local variable line to caller's variable
set filechan [open $filename]
while {[gets $filechan line] != -1} {
uplevel 1 $code ; # Run supplied code in caller's scope
}
close $filechan
}</lang> Now we can use it to print the length of each line of file "mydata.txt": <lang tcl>forfilelines myline mydata.txt {
puts [string length $myline]
}</lang>
Visual Basic .NET
Goto
This skips the line that changes the value of x to 5.
<lang vbnet> Sub bar2()
Dim x = 0
GoTo label
x = 5
label:
Console.WriteLine(x) End Sub</lang>
On Error Goto
This brances in the event of an error. Usually there is an Exit (Sub|Function) to seperate the normal code from the error handling code
<lang vbnet> Sub foo()
On Error GoTo label
'do something dangerous
Exit Sub
label:
Console.WriteLine("Operation Failed")
End Sub</lang>
This style of code is rarely used.
On Error Resume Next
This performs a sequence of actions. If any action fails, the exception is discarded and next operation is performed.
<lang vbnet>Sub foo2()
On Error Resume Next Operation1() Operation2() Operation3() Operation4()
End Sub</lang>
This style of code is rarely used.
Return / Exit Sub
This shows the classical and modern syntax for exiting a sub routine early.
<lang vbnet>Sub Foo1()
If Not WorkNeeded() Then Exit Sub DoWork()
End Sub
Sub Foo2()
If Not WorkNeeded() Then Return DoWork()
End Sub</lang>
Return value / Exit Function
This shows the classical and modern syntax for exiting a function early. There is an implied variable with the same name as the function. This variable is write-only.
<lang vbnet>Function Foo3()
Foo3 = CalculateValue() If Not MoreWorkNeeded() Then Exit Function Foo3 = CalculateAnotherValue()
End Function
Function Foo4()
Dim result = CalculateValue() If Not MoreWorkNeeded() Then Return result Return CalculateAnotherValue()
End Function</lang>