<!DOCTYPE html>
<!--[if IE 8]><html class="no-js lt-ie9" lang="en" > <![endif]-->
<!--[if gt IE 8]><!--> <html class="no-js" lang="en" > <!--<![endif]-->
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Control Flow — Julia Language 0.3.4 documentation</title>
<link href='https://fonts.googleapis.com/css?family=Lato:400,700|Roboto+Slab:400,700|Inconsolata:400,700' rel='stylesheet' type='text/css'>
<link rel="stylesheet" href="../_static/julia.css" type="text/css" />
<link rel="stylesheet" href="../_static/julia.css" type="text/css" />
<link rel="top" title="Julia Language 0.3.4 documentation" href="../index.html"/>
<link rel="next" title="Scope of Variables" href="variables-and-scoping.html"/>
<link rel="prev" title="Functions" href="functions.html"/>
<script src="https://cdnjs.cloudflare.com/ajax/libs/modernizr/2.6.2/modernizr.min.js"></script>
</head>
<body class="wy-body-for-nav" role="document">
<div class="wy-grid-for-nav">
<nav data-toggle="wy-nav-shift" class="wy-nav-side">
<div class="wy-side-nav-search">
<a href="http://julialang.org/"><img src="../_static/julia-logo.svg" class="logo"></a>
<!--
<a href="../index.html" class="fa fa-home"> Julia Language</a>
-->
<div role="search">
<form id ="rtd-search-form" class="wy-form" action="../search.html" method="get">
<input type="text" name="q" placeholder="Search docs" />
<input type="hidden" name="check_keywords" value="yes" />
<input type="hidden" name="area" value="default" />
</form>
</div>
</div>
<div class="wy-menu wy-menu-vertical" data-spy="affix" role="navigation" aria-label="main navigation">
<ul class="current">
<li class="toctree-l1"><a class="reference internal" href="introduction.html">Introduction</a></li>
<li class="toctree-l1"><a class="reference internal" href="getting-started.html">Getting Started</a><ul>
<li class="toctree-l2"><a class="reference internal" href="getting-started.html#resources">Resources</a></li>
</ul>
</li>
<li class="toctree-l1"><a class="reference internal" href="variables.html">Variables</a><ul>
<li class="toctree-l2"><a class="reference internal" href="variables.html#allowed-variable-names">Allowed Variable Names</a></li>
<li class="toctree-l2"><a class="reference internal" href="variables.html#stylistic-conventions">Stylistic Conventions</a></li>
</ul>
</li>
<li class="toctree-l1"><a class="reference internal" href="integers-and-floating-point-numbers.html">Integers and Floating-Point Numbers</a><ul>
<li class="toctree-l2"><a class="reference internal" href="integers-and-floating-point-numbers.html#integers">Integers</a></li>
<li class="toctree-l2"><a class="reference internal" href="integers-and-floating-point-numbers.html#floating-point-numbers">Floating-Point Numbers</a></li>
<li class="toctree-l2"><a class="reference internal" href="integers-and-floating-point-numbers.html#arbitrary-precision-arithmetic">Arbitrary Precision Arithmetic</a></li>
<li class="toctree-l2"><a class="reference internal" href="integers-and-floating-point-numbers.html#numeric-literal-coefficients">Numeric Literal Coefficients</a></li>
<li class="toctree-l2"><a class="reference internal" href="integers-and-floating-point-numbers.html#literal-zero-and-one">Literal zero and one</a></li>
</ul>
</li>
<li class="toctree-l1"><a class="reference internal" href="mathematical-operations.html">Mathematical Operations and Elementary Functions</a><ul>
<li class="toctree-l2"><a class="reference internal" href="mathematical-operations.html#arithmetic-operators">Arithmetic Operators</a></li>
<li class="toctree-l2"><a class="reference internal" href="mathematical-operations.html#bitwise-operators">Bitwise Operators</a></li>
<li class="toctree-l2"><a class="reference internal" href="mathematical-operations.html#updating-operators">Updating operators</a></li>
<li class="toctree-l2"><a class="reference internal" href="mathematical-operations.html#numeric-comparisons">Numeric Comparisons</a></li>
<li class="toctree-l2"><a class="reference internal" href="mathematical-operations.html#elementary-functions">Elementary Functions</a></li>
</ul>
</li>
<li class="toctree-l1"><a class="reference internal" href="complex-and-rational-numbers.html">Complex and Rational Numbers</a><ul>
<li class="toctree-l2"><a class="reference internal" href="complex-and-rational-numbers.html#complex-numbers">Complex Numbers</a></li>
<li class="toctree-l2"><a class="reference internal" href="complex-and-rational-numbers.html#rational-numbers">Rational Numbers</a></li>
</ul>
</li>
<li class="toctree-l1"><a class="reference internal" href="strings.html">Strings</a><ul>
<li class="toctree-l2"><a class="reference internal" href="strings.html#characters">Characters</a></li>
<li class="toctree-l2"><a class="reference internal" href="strings.html#string-basics">String Basics</a></li>
<li class="toctree-l2"><a class="reference internal" href="strings.html#unicode-and-utf-8">Unicode and UTF-8</a></li>
<li class="toctree-l2"><a class="reference internal" href="strings.html#interpolation">Interpolation</a></li>
<li class="toctree-l2"><a class="reference internal" href="strings.html#common-operations">Common Operations</a></li>
<li class="toctree-l2"><a class="reference internal" href="strings.html#non-standard-string-literals">Non-Standard String Literals</a></li>
<li class="toctree-l2"><a class="reference internal" href="strings.html#regular-expressions">Regular Expressions</a></li>
<li class="toctree-l2"><a class="reference internal" href="strings.html#id3">Byte Array Literals</a></li>
<li class="toctree-l2"><a class="reference internal" href="strings.html#version-number-literals">Version Number Literals</a></li>
</ul>
</li>
<li class="toctree-l1"><a class="reference internal" href="functions.html">Functions</a><ul>
<li class="toctree-l2"><a class="reference internal" href="functions.html#argument-passing-behavior">Argument Passing Behavior</a></li>
<li class="toctree-l2"><a class="reference internal" href="functions.html#the-return-keyword">The <tt class="docutils literal"><span class="pre">return</span></tt> Keyword</a></li>
<li class="toctree-l2"><a class="reference internal" href="functions.html#id1">Operators Are Functions</a></li>
<li class="toctree-l2"><a class="reference internal" href="functions.html#operators-with-special-names">Operators With Special Names</a></li>
<li class="toctree-l2"><a class="reference internal" href="functions.html#anonymous-functions">Anonymous Functions</a></li>
<li class="toctree-l2"><a class="reference internal" href="functions.html#multiple-return-values">Multiple Return Values</a></li>
<li class="toctree-l2"><a class="reference internal" href="functions.html#varargs-functions">Varargs Functions</a></li>
<li class="toctree-l2"><a class="reference internal" href="functions.html#optional-arguments">Optional Arguments</a></li>
<li class="toctree-l2"><a class="reference internal" href="functions.html#keyword-arguments">Keyword Arguments</a></li>
<li class="toctree-l2"><a class="reference internal" href="functions.html#evaluation-scope-of-default-values">Evaluation Scope of Default Values</a></li>
<li class="toctree-l2"><a class="reference internal" href="functions.html#block-syntax-for-function-arguments">Block Syntax for Function Arguments</a></li>
<li class="toctree-l2"><a class="reference internal" href="functions.html#further-reading">Further Reading</a></li>
</ul>
</li>
<li class="toctree-l1 current"><a class="current reference internal" href="">Control Flow</a><ul>
<li class="toctree-l2"><a class="reference internal" href="#compound-expressions">Compound Expressions</a></li>
<li class="toctree-l2"><a class="reference internal" href="#conditional-evaluation">Conditional Evaluation</a></li>
<li class="toctree-l2"><a class="reference internal" href="#short-circuit-evaluation">Short-Circuit Evaluation</a></li>
<li class="toctree-l2"><a class="reference internal" href="#repeated-evaluation-loops">Repeated Evaluation: Loops</a></li>
<li class="toctree-l2"><a class="reference internal" href="#exception-handling">Exception Handling</a></li>
<li class="toctree-l2"><a class="reference internal" href="#tasks-aka-coroutines">Tasks (aka Coroutines)</a></li>
</ul>
</li>
<li class="toctree-l1"><a class="reference internal" href="variables-and-scoping.html">Scope of Variables</a><ul>
<li class="toctree-l2"><a class="reference internal" href="variables-and-scoping.html#for-loops-and-comprehensions">For Loops and Comprehensions</a></li>
<li class="toctree-l2"><a class="reference internal" href="variables-and-scoping.html#constants">Constants</a></li>
</ul>
</li>
<li class="toctree-l1"><a class="reference internal" href="types.html">Types</a><ul>
<li class="toctree-l2"><a class="reference internal" href="types.html#type-declarations">Type Declarations</a></li>
<li class="toctree-l2"><a class="reference internal" href="types.html#abstract-types">Abstract Types</a></li>
<li class="toctree-l2"><a class="reference internal" href="types.html#bits-types">Bits Types</a></li>
<li class="toctree-l2"><a class="reference internal" href="types.html#composite-types">Composite Types</a></li>
<li class="toctree-l2"><a class="reference internal" href="types.html#immutable-composite-types">Immutable Composite Types</a></li>
<li class="toctree-l2"><a class="reference internal" href="types.html#declared-types">Declared Types</a></li>
<li class="toctree-l2"><a class="reference internal" href="types.html#tuple-types">Tuple Types</a></li>
<li class="toctree-l2"><a class="reference internal" href="types.html#type-unions">Type Unions</a></li>
<li class="toctree-l2"><a class="reference internal" href="types.html#man-parametric-types">Parametric Types</a></li>
<li class="toctree-l2"><a class="reference internal" href="types.html#type-aliases">Type Aliases</a></li>
<li class="toctree-l2"><a class="reference internal" href="types.html#operations-on-types">Operations on Types</a></li>
</ul>
</li>
<li class="toctree-l1"><a class="reference internal" href="methods.html">Methods</a><ul>
<li class="toctree-l2"><a class="reference internal" href="methods.html#defining-methods">Defining Methods</a></li>
<li class="toctree-l2"><a class="reference internal" href="methods.html#method-ambiguities">Method Ambiguities</a></li>
<li class="toctree-l2"><a class="reference internal" href="methods.html#parametric-methods">Parametric Methods</a></li>
<li class="toctree-l2"><a class="reference internal" href="methods.html#note-on-optional-and-keyword-arguments">Note on Optional and keyword Arguments</a></li>
</ul>
</li>
<li class="toctree-l1"><a class="reference internal" href="constructors.html">Constructors</a><ul>
<li class="toctree-l2"><a class="reference internal" href="constructors.html#outer-constructor-methods">Outer Constructor Methods</a></li>
<li class="toctree-l2"><a class="reference internal" href="constructors.html#inner-constructor-methods">Inner Constructor Methods</a></li>
<li class="toctree-l2"><a class="reference internal" href="constructors.html#incomplete-initialization">Incomplete Initialization</a></li>
<li class="toctree-l2"><a class="reference internal" href="constructors.html#parametric-constructors">Parametric Constructors</a></li>
<li class="toctree-l2"><a class="reference internal" href="constructors.html#case-study-rational">Case Study: Rational</a></li>
</ul>
</li>
<li class="toctree-l1"><a class="reference internal" href="conversion-and-promotion.html">Conversion and Promotion</a><ul>
<li class="toctree-l2"><a class="reference internal" href="conversion-and-promotion.html#conversion">Conversion</a></li>
<li class="toctree-l2"><a class="reference internal" href="conversion-and-promotion.html#promotion">Promotion</a></li>
</ul>
</li>
<li class="toctree-l1"><a class="reference internal" href="modules.html">Modules</a><ul>
<li class="toctree-l2"><a class="reference internal" href="modules.html#summary-of-module-usage">Summary of module usage</a></li>
</ul>
</li>
<li class="toctree-l1"><a class="reference internal" href="metaprogramming.html">Metaprogramming</a><ul>
<li class="toctree-l2"><a class="reference internal" href="metaprogramming.html#expressions-and-eval">Expressions and Eval</a></li>
<li class="toctree-l2"><a class="reference internal" href="metaprogramming.html#macros">Macros</a></li>
<li class="toctree-l2"><a class="reference internal" href="metaprogramming.html#reflection">Reflection</a></li>
</ul>
</li>
<li class="toctree-l1"><a class="reference internal" href="arrays.html">Multi-dimensional Arrays</a><ul>
<li class="toctree-l2"><a class="reference internal" href="arrays.html#arrays">Arrays</a></li>
<li class="toctree-l2"><a class="reference internal" href="arrays.html#sparse-matrices">Sparse Matrices</a></li>
</ul>
</li>
<li class="toctree-l1"><a class="reference internal" href="linear-algebra.html">Linear algebra</a><ul>
<li class="toctree-l2"><a class="reference internal" href="linear-algebra.html#matrix-factorizations">Matrix factorizations</a></li>
<li class="toctree-l2"><a class="reference internal" href="linear-algebra.html#special-matrices">Special matrices</a></li>
</ul>
</li>
<li class="toctree-l1"><a class="reference internal" href="networking-and-streams.html">Networking and Streams</a><ul>
<li class="toctree-l2"><a class="reference internal" href="networking-and-streams.html#basic-stream-i-o">Basic Stream I/O</a></li>
<li class="toctree-l2"><a class="reference internal" href="networking-and-streams.html#text-i-o">Text I/O</a></li>
<li class="toctree-l2"><a class="reference internal" href="networking-and-streams.html#working-with-files">Working with Files</a></li>
<li class="toctree-l2"><a class="reference internal" href="networking-and-streams.html#a-simple-tcp-example">A simple TCP example</a></li>
<li class="toctree-l2"><a class="reference internal" href="networking-and-streams.html#resolving-ip-addresses">Resolving IP Addresses</a></li>
</ul>
</li>
<li class="toctree-l1"><a class="reference internal" href="parallel-computing.html">Parallel Computing</a><ul>
<li class="toctree-l2"><a class="reference internal" href="parallel-computing.html#data-movement">Data Movement</a></li>
<li class="toctree-l2"><a class="reference internal" href="parallel-computing.html#parallel-map-and-loops">Parallel Map and Loops</a></li>
<li class="toctree-l2"><a class="reference internal" href="parallel-computing.html#synchronization-with-remote-references">Synchronization With Remote References</a></li>
<li class="toctree-l2"><a class="reference internal" href="parallel-computing.html#scheduling">Scheduling</a></li>
<li class="toctree-l2"><a class="reference internal" href="parallel-computing.html#distributed-arrays">Distributed Arrays</a></li>
<li class="toctree-l2"><a class="reference internal" href="parallel-computing.html#constructing-distributed-arrays">Constructing Distributed Arrays</a></li>
<li class="toctree-l2"><a class="reference internal" href="parallel-computing.html#distributed-array-operations">Distributed Array Operations</a></li>
<li class="toctree-l2"><a class="reference internal" href="parallel-computing.html#shared-arrays-experimental">Shared Arrays (Experimental)</a></li>
<li class="toctree-l2"><a class="reference internal" href="parallel-computing.html#clustermanagers">ClusterManagers</a></li>
</ul>
</li>
<li class="toctree-l1"><a class="reference internal" href="running-external-programs.html">Running External Programs</a><ul>
<li class="toctree-l2"><a class="reference internal" href="running-external-programs.html#interpolation">Interpolation</a></li>
<li class="toctree-l2"><a class="reference internal" href="running-external-programs.html#quoting">Quoting</a></li>
<li class="toctree-l2"><a class="reference internal" href="running-external-programs.html#pipelines">Pipelines</a></li>
</ul>
</li>
<li class="toctree-l1"><a class="reference internal" href="calling-c-and-fortran-code.html">Calling C and Fortran Code</a><ul>
<li class="toctree-l2"><a class="reference internal" href="calling-c-and-fortran-code.html#mapping-c-types-to-julia">Mapping C Types to Julia</a></li>
<li class="toctree-l2"><a class="reference internal" href="calling-c-and-fortran-code.html#accessing-data-through-a-pointer">Accessing Data through a Pointer</a></li>
<li class="toctree-l2"><a class="reference internal" href="calling-c-and-fortran-code.html#passing-pointers-for-modifying-inputs">Passing Pointers for Modifying Inputs</a></li>
<li class="toctree-l2"><a class="reference internal" href="calling-c-and-fortran-code.html#garbage-collection-safety">Garbage Collection Safety</a></li>
<li class="toctree-l2"><a class="reference internal" href="calling-c-and-fortran-code.html#non-constant-function-specifications">Non-constant Function Specifications</a></li>
<li class="toctree-l2"><a class="reference internal" href="calling-c-and-fortran-code.html#indirect-calls">Indirect Calls</a></li>
<li class="toctree-l2"><a class="reference internal" href="calling-c-and-fortran-code.html#calling-convention">Calling Convention</a></li>
<li class="toctree-l2"><a class="reference internal" href="calling-c-and-fortran-code.html#accessing-global-variables">Accessing Global Variables</a></li>
<li class="toctree-l2"><a class="reference internal" href="calling-c-and-fortran-code.html#passing-julia-callback-functions-to-c">Passing Julia Callback Functions to C</a></li>
<li class="toctree-l2"><a class="reference internal" href="calling-c-and-fortran-code.html#c">C++</a></li>
<li class="toctree-l2"><a class="reference internal" href="calling-c-and-fortran-code.html#handling-platform-variations">Handling Platform Variations</a></li>
</ul>
</li>
<li class="toctree-l1"><a class="reference internal" href="interacting-with-julia.html">Interacting With Julia</a><ul>
<li class="toctree-l2"><a class="reference internal" href="interacting-with-julia.html#the-different-prompt-modes">The different prompt modes</a></li>
<li class="toctree-l2"><a class="reference internal" href="interacting-with-julia.html#key-bindings">Key bindings</a></li>
</ul>
</li>
<li class="toctree-l1"><a class="reference internal" href="embedding.html">Embedding Julia</a><ul>
<li class="toctree-l2"><a class="reference internal" href="embedding.html#high-level-embedding">High-Level Embedding</a></li>
<li class="toctree-l2"><a class="reference internal" href="embedding.html#converting-types">Converting Types</a></li>
<li class="toctree-l2"><a class="reference internal" href="embedding.html#calling-julia-functions">Calling Julia Functions</a></li>
<li class="toctree-l2"><a class="reference internal" href="embedding.html#memory-management">Memory Management</a></li>
<li class="toctree-l2"><a class="reference internal" href="embedding.html#working-with-arrays">Working with Arrays</a></li>
<li class="toctree-l2"><a class="reference internal" href="embedding.html#exceptions">Exceptions</a></li>
</ul>
</li>
<li class="toctree-l1"><a class="reference internal" href="packages.html">Packages</a><ul>
<li class="toctree-l2"><a class="reference internal" href="packages.html#package-status">Package Status</a></li>
<li class="toctree-l2"><a class="reference internal" href="packages.html#adding-and-removing-packages">Adding and Removing Packages</a></li>
<li class="toctree-l2"><a class="reference internal" href="packages.html#installing-unregistered-packages">Installing Unregistered Packages</a></li>
<li class="toctree-l2"><a class="reference internal" href="packages.html#updating-packages">Updating Packages</a></li>
<li class="toctree-l2"><a class="reference internal" href="packages.html#checkout-pin-and-free">Checkout, Pin and Free</a></li>
</ul>
</li>
<li class="toctree-l1"><a class="reference internal" href="packages.html#package-development">Package Development</a><ul>
<li class="toctree-l2"><a class="reference internal" href="packages.html#initial-setup">Initial Setup</a></li>
<li class="toctree-l2"><a class="reference internal" href="packages.html#generating-a-new-package">Generating a New Package</a></li>
<li class="toctree-l2"><a class="reference internal" href="packages.html#making-your-package-available">Making Your Package Available</a></li>
<li class="toctree-l2"><a class="reference internal" href="packages.html#publishing-your-package">Publishing Your Package</a></li>
<li class="toctree-l2"><a class="reference internal" href="packages.html#tagging-package-versions">Tagging Package Versions</a></li>
<li class="toctree-l2"><a class="reference internal" href="packages.html#fixing-package-requirements">Fixing Package Requirements</a></li>
<li class="toctree-l2"><a class="reference internal" href="packages.html#man-package-requirements">Requirements Specification</a></li>
</ul>
</li>
<li class="toctree-l1"><a class="reference internal" href="performance-tips.html">Performance Tips</a><ul>
<li class="toctree-l2"><a class="reference internal" href="performance-tips.html#avoid-global-variables">Avoid global variables</a></li>
<li class="toctree-l2"><a class="reference internal" href="performance-tips.html#measure-performance-with-time-and-pay-attention-to-memory-allocation">Measure performance with <tt class="docutils literal"><span class="pre">@time</span></tt> and pay attention to memory allocation</a></li>
<li class="toctree-l2"><a class="reference internal" href="performance-tips.html#tools">Tools</a></li>
<li class="toctree-l2"><a class="reference internal" href="performance-tips.html#avoid-containers-with-abstract-type-parameters">Avoid containers with abstract type parameters</a></li>
<li class="toctree-l2"><a class="reference internal" href="performance-tips.html#type-declarations">Type declarations</a></li>
<li class="toctree-l2"><a class="reference internal" href="performance-tips.html#break-functions-into-multiple-definitions">Break functions into multiple definitions</a></li>
<li class="toctree-l2"><a class="reference internal" href="performance-tips.html#write-type-stable-functions">Write “type-stable” functions</a></li>
<li class="toctree-l2"><a class="reference internal" href="performance-tips.html#avoid-changing-the-type-of-a-variable">Avoid changing the type of a variable</a></li>
<li class="toctree-l2"><a class="reference internal" href="performance-tips.html#separate-kernel-functions">Separate kernel functions</a></li>
<li class="toctree-l2"><a class="reference internal" href="performance-tips.html#access-arrays-in-memory-order-along-columns">Access arrays in memory order, along columns</a></li>
<li class="toctree-l2"><a class="reference internal" href="performance-tips.html#pre-allocating-outputs">Pre-allocating outputs</a></li>
<li class="toctree-l2"><a class="reference internal" href="performance-tips.html#avoid-string-interpolation-for-i-o">Avoid string interpolation for I/O</a></li>
<li class="toctree-l2"><a class="reference internal" href="performance-tips.html#fix-deprecation-warnings">Fix deprecation warnings</a></li>
<li class="toctree-l2"><a class="reference internal" href="performance-tips.html#tweaks">Tweaks</a></li>
<li class="toctree-l2"><a class="reference internal" href="performance-tips.html#performance-annotations">Performance Annotations</a></li>
</ul>
</li>
<li class="toctree-l1"><a class="reference internal" href="style-guide.html">Style Guide</a><ul>
<li class="toctree-l2"><a class="reference internal" href="style-guide.html#write-functions-not-just-scripts">Write functions, not just scripts</a></li>
<li class="toctree-l2"><a class="reference internal" href="style-guide.html#avoid-writing-overly-specific-types">Avoid writing overly-specific types</a></li>
<li class="toctree-l2"><a class="reference internal" href="style-guide.html#handle-excess-argument-diversity-in-the-caller">Handle excess argument diversity in the caller</a></li>
<li class="toctree-l2"><a class="reference internal" href="style-guide.html#append-to-names-of-functions-that-modify-their-arguments">Append <cite>!</cite> to names of functions that modify their arguments</a></li>
<li class="toctree-l2"><a class="reference internal" href="style-guide.html#avoid-strange-type-unions">Avoid strange type Unions</a></li>
<li class="toctree-l2"><a class="reference internal" href="style-guide.html#try-to-avoid-nullable-fields">Try to avoid nullable fields</a></li>
<li class="toctree-l2"><a class="reference internal" href="style-guide.html#avoid-elaborate-container-types">Avoid elaborate container types</a></li>
<li class="toctree-l2"><a class="reference internal" href="style-guide.html#avoid-underscores-in-names">Avoid underscores in names</a></li>
<li class="toctree-l2"><a class="reference internal" href="style-guide.html#don-t-overuse-try-catch">Don’t overuse try-catch</a></li>
<li class="toctree-l2"><a class="reference internal" href="style-guide.html#don-t-parenthesize-conditions">Don’t parenthesize conditions</a></li>
<li class="toctree-l2"><a class="reference internal" href="style-guide.html#don-t-overuse">Don’t overuse ...</a></li>
<li class="toctree-l2"><a class="reference internal" href="style-guide.html#don-t-use-unnecessary-static-parameters">Don’t use unnecessary static parameters</a></li>
<li class="toctree-l2"><a class="reference internal" href="style-guide.html#avoid-confusion-about-whether-something-is-an-instance-or-a-type">Avoid confusion about whether something is an instance or a type</a></li>
<li class="toctree-l2"><a class="reference internal" href="style-guide.html#don-t-overuse-macros">Don’t overuse macros</a></li>
<li class="toctree-l2"><a class="reference internal" href="style-guide.html#don-t-expose-unsafe-operations-at-the-interface-level">Don’t expose unsafe operations at the interface level</a></li>
<li class="toctree-l2"><a class="reference internal" href="style-guide.html#don-t-overload-methods-of-base-container-types">Don’t overload methods of base container types</a></li>
<li class="toctree-l2"><a class="reference internal" href="style-guide.html#be-careful-with-type-equality">Be careful with type equality</a></li>
<li class="toctree-l2"><a class="reference internal" href="style-guide.html#do-not-write-x-f-x">Do not write <tt class="docutils literal"><span class="pre">x->f(x)</span></tt></a></li>
</ul>
</li>
<li class="toctree-l1"><a class="reference internal" href="faq.html">Frequently Asked Questions</a><ul>
<li class="toctree-l2"><a class="reference internal" href="faq.html#sessions-and-the-repl">Sessions and the REPL</a></li>
<li class="toctree-l2"><a class="reference internal" href="faq.html#functions">Functions</a></li>
<li class="toctree-l2"><a class="reference internal" href="faq.html#types-type-declarations-and-constructors">Types, type declarations, and constructors</a></li>
<li class="toctree-l2"><a class="reference internal" href="faq.html#nothingness-and-missing-values">Nothingness and missing values</a></li>
<li class="toctree-l2"><a class="reference internal" href="faq.html#julia-releases">Julia Releases</a></li>
<li class="toctree-l2"><a class="reference internal" href="faq.html#developing-julia">Developing Julia</a></li>
</ul>
</li>
<li class="toctree-l1"><a class="reference internal" href="noteworthy-differences.html">Noteworthy Differences from other Languages</a><ul>
<li class="toctree-l2"><a class="reference internal" href="noteworthy-differences.html#noteworthy-differences-from-matlab">Noteworthy differences from MATLAB</a></li>
<li class="toctree-l2"><a class="reference internal" href="noteworthy-differences.html#noteworthy-differences-from-r">Noteworthy differences from R</a></li>
<li class="toctree-l2"><a class="reference internal" href="noteworthy-differences.html#noteworthy-differences-from-python">Noteworthy differences from Python</a></li>
</ul>
</li>
</ul>
<ul>
<li class="toctree-l1"><a class="reference internal" href="../stdlib/base.html">The Standard Library</a><ul>
<li class="toctree-l2"><a class="reference internal" href="../stdlib/base.html#introduction">Introduction</a></li>
<li class="toctree-l2"><a class="reference internal" href="../stdlib/base.html#getting-around">Getting Around</a></li>
<li class="toctree-l2"><a class="reference internal" href="../stdlib/base.html#all-objects">All Objects</a></li>
<li class="toctree-l2"><a class="reference internal" href="../stdlib/base.html#types">Types</a></li>
<li class="toctree-l2"><a class="reference internal" href="../stdlib/base.html#generic-functions">Generic Functions</a></li>
<li class="toctree-l2"><a class="reference internal" href="../stdlib/base.html#syntax">Syntax</a></li>
<li class="toctree-l2"><a class="reference internal" href="../stdlib/base.html#iteration">Iteration</a></li>
<li class="toctree-l2"><a class="reference internal" href="../stdlib/base.html#general-collections">General Collections</a></li>
<li class="toctree-l2"><a class="reference internal" href="../stdlib/base.html#iterable-collections">Iterable Collections</a></li>
<li class="toctree-l2"><a class="reference internal" href="../stdlib/base.html#indexable-collections">Indexable Collections</a></li>
<li class="toctree-l2"><a class="reference internal" href="../stdlib/base.html#associative-collections">Associative Collections</a></li>
<li class="toctree-l2"><a class="reference internal" href="../stdlib/base.html#set-like-collections">Set-Like Collections</a></li>
<li class="toctree-l2"><a class="reference internal" href="../stdlib/base.html#dequeues">Dequeues</a></li>
<li class="toctree-l2"><a class="reference internal" href="../stdlib/base.html#strings">Strings</a></li>
<li class="toctree-l2"><a class="reference internal" href="../stdlib/base.html#i-o">I/O</a></li>
<li class="toctree-l2"><a class="reference internal" href="../stdlib/base.html#network-i-o">Network I/O</a></li>
<li class="toctree-l2"><a class="reference internal" href="../stdlib/base.html#text-i-o">Text I/O</a></li>
<li class="toctree-l2"><a class="reference internal" href="../stdlib/base.html#multimedia-i-o">Multimedia I/O</a></li>
<li class="toctree-l2"><a class="reference internal" href="../stdlib/base.html#memory-mapped-i-o">Memory-mapped I/O</a></li>
<li class="toctree-l2"><a class="reference internal" href="../stdlib/base.html#standard-numeric-types">Standard Numeric Types</a></li>
<li class="toctree-l2"><a class="reference internal" href="../stdlib/base.html#mathematical-operators">Mathematical Operators</a></li>
<li class="toctree-l2"><a class="reference internal" href="../stdlib/base.html#mathematical-functions">Mathematical Functions</a></li>
<li class="toctree-l2"><a class="reference internal" href="../stdlib/base.html#data-formats">Data Formats</a></li>
<li class="toctree-l2"><a class="reference internal" href="../stdlib/base.html#numbers">Numbers</a></li>
<li class="toctree-l2"><a class="reference internal" href="../stdlib/base.html#bigfloats">BigFloats</a></li>
<li class="toctree-l2"><a class="reference internal" href="../stdlib/base.html#random-numbers">Random Numbers</a></li>
<li class="toctree-l2"><a class="reference internal" href="../stdlib/base.html#arrays">Arrays</a></li>
<li class="toctree-l2"><a class="reference internal" href="../stdlib/base.html#combinatorics">Combinatorics</a></li>
<li class="toctree-l2"><a class="reference internal" href="../stdlib/base.html#statistics">Statistics</a></li>
<li class="toctree-l2"><a class="reference internal" href="../stdlib/base.html#signal-processing">Signal Processing</a></li>
<li class="toctree-l2"><a class="reference internal" href="../stdlib/base.html#numerical-integration">Numerical Integration</a></li>
<li class="toctree-l2"><a class="reference internal" href="../stdlib/base.html#parallel-computing">Parallel Computing</a></li>
<li class="toctree-l2"><a class="reference internal" href="../stdlib/base.html#distributed-arrays">Distributed Arrays</a></li>
<li class="toctree-l2"><a class="reference internal" href="../stdlib/base.html#shared-arrays-experimental-unix-only-feature">Shared Arrays (Experimental, UNIX-only feature)</a></li>
<li class="toctree-l2"><a class="reference internal" href="../stdlib/base.html#system">System</a></li>
<li class="toctree-l2"><a class="reference internal" href="../stdlib/base.html#c-interface">C Interface</a></li>
<li class="toctree-l2"><a class="reference internal" href="../stdlib/base.html#errors">Errors</a></li>
<li class="toctree-l2"><a class="reference internal" href="../stdlib/base.html#tasks">Tasks</a></li>
<li class="toctree-l2"><a class="reference internal" href="../stdlib/base.html#events">Events</a></li>
<li class="toctree-l2"><a class="reference internal" href="../stdlib/base.html#reflection">Reflection</a></li>
<li class="toctree-l2"><a class="reference internal" href="../stdlib/base.html#internals">Internals</a></li>
</ul>
</li>
<li class="toctree-l1"><a class="reference internal" href="../stdlib/sparse.html">Sparse Matrices</a></li>
<li class="toctree-l1"><a class="reference internal" href="../stdlib/linalg.html">Linear Algebra</a></li>
<li class="toctree-l1"><a class="reference internal" href="../stdlib/linalg.html#module-Base.LinAlg.BLAS">BLAS Functions</a></li>
<li class="toctree-l1"><a class="reference internal" href="../stdlib/constants.html">Constants</a></li>
<li class="toctree-l1"><a class="reference internal" href="../stdlib/file.html">Filesystem</a></li>
<li class="toctree-l1"><a class="reference internal" href="../stdlib/punctuation.html">Punctuation</a></li>
<li class="toctree-l1"><a class="reference internal" href="../stdlib/sort.html">Sorting and Related Functions</a><ul>
<li class="toctree-l2"><a class="reference internal" href="../stdlib/sort.html#sorting-functions">Sorting Functions</a></li>
<li class="toctree-l2"><a class="reference internal" href="../stdlib/sort.html#order-related-functions">Order-Related Functions</a></li>
<li class="toctree-l2"><a class="reference internal" href="../stdlib/sort.html#sorting-algorithms">Sorting Algorithms</a></li>
</ul>
</li>
<li class="toctree-l1"><a class="reference internal" href="../stdlib/pkg.html">Package Manager Functions</a></li>
<li class="toctree-l1"><a class="reference internal" href="../stdlib/collections.html">Collections and Data Structures</a><ul>
<li class="toctree-l2"><a class="reference internal" href="../stdlib/collections.html#priorityqueue">PriorityQueue</a></li>
<li class="toctree-l2"><a class="reference internal" href="../stdlib/collections.html#heap-functions">Heap Functions</a></li>
</ul>
</li>
<li class="toctree-l1"><a class="reference internal" href="../stdlib/graphics.html">Graphics</a><ul>
<li class="toctree-l2"><a class="reference internal" href="../stdlib/graphics.html#geometry">Geometry</a></li>
</ul>
</li>
<li class="toctree-l1"><a class="reference internal" href="../stdlib/test.html">Unit and Functional Testing</a><ul>
<li class="toctree-l2"><a class="reference internal" href="../stdlib/test.html#overview">Overview</a></li>
<li class="toctree-l2"><a class="reference internal" href="../stdlib/test.html#handlers">Handlers</a></li>
<li class="toctree-l2"><a class="reference internal" href="../stdlib/test.html#macros">Macros</a></li>
<li class="toctree-l2"><a class="reference internal" href="../stdlib/test.html#functions">Functions</a></li>
</ul>
</li>
<li class="toctree-l1"><a class="reference internal" href="../stdlib/test.html#testing-base-julia">Testing Base Julia</a></li>
<li class="toctree-l1"><a class="reference internal" href="../stdlib/profile.html">Profiling</a><ul>
<li class="toctree-l2"><a class="reference internal" href="../stdlib/profile.html#basic-usage">Basic usage</a></li>
<li class="toctree-l2"><a class="reference internal" href="../stdlib/profile.html#accumulation-and-clearing">Accumulation and clearing</a></li>
<li class="toctree-l2"><a class="reference internal" href="../stdlib/profile.html#options-for-controlling-the-display-of-profile-results">Options for controlling the display of profile results</a></li>
<li class="toctree-l2"><a class="reference internal" href="../stdlib/profile.html#configuration">Configuration</a></li>
<li class="toctree-l2"><a class="reference internal" href="../stdlib/profile.html#function-reference">Function reference</a></li>
</ul>
</li>
</ul>
<ul>
<li class="toctree-l1"><a class="reference internal" href="../devdocs/julia.html">Documentation of Julia’s Internals</a><ul>
<li class="toctree-l2"><a class="reference internal" href="../devdocs/cartesian.html">Base.Cartesian</a></li>
<li class="toctree-l2"><a class="reference internal" href="../devdocs/sysimg.html">System Image Building</a></li>
</ul>
</li>
<li class="toctree-l1"><a class="reference internal" href="../devdocs/C.html">Developing/debugging Julia’s C code</a><ul>
<li class="toctree-l2"><a class="reference internal" href="../devdocs/backtraces.html">Reporting and analyzing crashes (segfaults)</a></li>
<li class="toctree-l2"><a class="reference internal" href="../devdocs/debuggingtips.html">gdb debugging tips</a></li>
</ul>
</li>
</ul>
</div>
</nav>
<section data-toggle="wy-nav-shift" class="wy-nav-content-wrap">
<nav class="wy-nav-top" role="navigation" aria-label="top navigation">
<i data-toggle="wy-nav-top" class="fa fa-bars"></i>
<a href="../index.html">Julia Language</a>
</nav>
<div class="wy-nav-content">
<div class="rst-content">
<div role="navigation" aria-label="breadcrumbs navigation">
<ul class="wy-breadcrumbs">
<li><a href="../index.html">Docs</a> »</li>
<li>Control Flow</li>
<li class="wy-breadcrumbs-aside">
<a href="../_sources/manual/control-flow.txt" rel="nofollow"> View page source</a>
</li>
</ul>
<hr/>
</div>
<div role="main" class="document">
<div class="section" id="control-flow">
<span id="man-control-flow"></span><h1>Control Flow<a class="headerlink" href="#control-flow" title="Permalink to this headline">¶</a></h1>
<p>Julia provides a variety of control flow constructs:</p>
<ul class="simple">
<li><a class="reference internal" href="#man-compound-expressions"><em>Compound Expressions</em></a>: <tt class="docutils literal"><span class="pre">begin</span></tt> and <tt class="docutils literal"><span class="pre">(;)</span></tt>.</li>
<li><a class="reference internal" href="#man-conditional-evaluation"><em>Conditional Evaluation</em></a>:
<tt class="docutils literal"><span class="pre">if</span></tt>-<tt class="docutils literal"><span class="pre">elseif</span></tt>-<tt class="docutils literal"><span class="pre">else</span></tt> and <tt class="docutils literal"><span class="pre">?:</span></tt> (ternary operator).</li>
<li><a class="reference internal" href="#man-short-circuit-evaluation"><em>Short-Circuit Evaluation</em></a>:
<tt class="docutils literal"><span class="pre">&&</span></tt>, <tt class="docutils literal"><span class="pre">||</span></tt> and chained comparisons.</li>
<li><a class="reference internal" href="#man-loops"><em>Repeated Evaluation: Loops</em></a>: <tt class="docutils literal"><span class="pre">while</span></tt> and <tt class="docutils literal"><span class="pre">for</span></tt>.</li>
<li><a class="reference internal" href="#man-exception-handling"><em>Exception Handling</em></a>:
<tt class="docutils literal"><span class="pre">try</span></tt>-<tt class="docutils literal"><span class="pre">catch</span></tt>, <tt class="docutils literal"><span class="pre">error</span></tt> and <tt class="docutils literal"><span class="pre">throw</span></tt>.</li>
<li><a class="reference internal" href="#man-tasks"><em>Tasks (aka Coroutines)</em></a>: <tt class="docutils literal"><span class="pre">yieldto</span></tt>.</li>
</ul>
<p>The first five control flow mechanisms are standard to high-level
programming languages. Tasks are not so standard: they provide non-local
control flow, making it possible to switch between temporarily-suspended
computations. This is a powerful construct: both exception handling and
cooperative multitasking are implemented in Julia using tasks. Everyday
programming requires no direct usage of tasks, but certain problems can
be solved much more easily by using tasks.</p>
<div class="section" id="compound-expressions">
<span id="man-compound-expressions"></span><h2>Compound Expressions<a class="headerlink" href="#compound-expressions" title="Permalink to this headline">¶</a></h2>
<p>Sometimes it is convenient to have a single expression which evaluates
several subexpressions in order, returning the value of the last
subexpression as its value. There are two Julia constructs that
accomplish this: <tt class="docutils literal"><span class="pre">begin</span></tt> blocks and <tt class="docutils literal"><span class="pre">(;)</span></tt> chains. The value of both
compound expression constructs is that of the last subexpression. Here’s
an example of a <tt class="docutils literal"><span class="pre">begin</span></tt> block:</p>
<div class="highlight-julia"><div class="highlight"><pre><span class="n">julia</span><span class="o">></span> <span class="n">z</span> <span class="o">=</span> <span class="k">begin</span>
<span class="n">x</span> <span class="o">=</span> <span class="mi">1</span>
<span class="n">y</span> <span class="o">=</span> <span class="mi">2</span>
<span class="n">x</span> <span class="o">+</span> <span class="n">y</span>
<span class="k">end</span>
<span class="mi">3</span>
</pre></div>
</div>
<p>Since these are fairly small, simple expressions, they could easily be
placed onto a single line, which is where the <tt class="docutils literal"><span class="pre">(;)</span></tt> chain syntax comes
in handy:</p>
<div class="highlight-julia"><div class="highlight"><pre><span class="n">julia</span><span class="o">></span> <span class="n">z</span> <span class="o">=</span> <span class="p">(</span><span class="n">x</span> <span class="o">=</span> <span class="mi">1</span><span class="p">;</span> <span class="n">y</span> <span class="o">=</span> <span class="mi">2</span><span class="p">;</span> <span class="n">x</span> <span class="o">+</span> <span class="n">y</span><span class="p">)</span>
<span class="mi">3</span>
</pre></div>
</div>
<p>This syntax is particularly useful with the terse single-line function
definition form introduced in <a class="reference internal" href="functions.html#man-functions"><em>Functions</em></a>. Although it
is typical, there is no requirement that <tt class="docutils literal"><span class="pre">begin</span></tt> blocks be multiline
or that <tt class="docutils literal"><span class="pre">(;)</span></tt> chains be single-line:</p>
<div class="highlight-julia"><div class="highlight"><pre><span class="n">julia</span><span class="o">></span> <span class="k">begin</span> <span class="n">x</span> <span class="o">=</span> <span class="mi">1</span><span class="p">;</span> <span class="n">y</span> <span class="o">=</span> <span class="mi">2</span><span class="p">;</span> <span class="n">x</span> <span class="o">+</span> <span class="n">y</span> <span class="k">end</span>
<span class="mi">3</span>
<span class="n">julia</span><span class="o">></span> <span class="p">(</span><span class="n">x</span> <span class="o">=</span> <span class="mi">1</span><span class="p">;</span>
<span class="n">y</span> <span class="o">=</span> <span class="mi">2</span><span class="p">;</span>
<span class="n">x</span> <span class="o">+</span> <span class="n">y</span><span class="p">)</span>
<span class="mi">3</span>
</pre></div>
</div>
</div>
<div class="section" id="conditional-evaluation">
<span id="man-conditional-evaluation"></span><h2>Conditional Evaluation<a class="headerlink" href="#conditional-evaluation" title="Permalink to this headline">¶</a></h2>
<p>Conditional evaluation allows portions of code to be evaluated or not
evaluated depending on the value of a boolean expression. Here is the
anatomy of the <tt class="docutils literal"><span class="pre">if</span></tt>-<tt class="docutils literal"><span class="pre">elseif</span></tt>-<tt class="docutils literal"><span class="pre">else</span></tt> conditional syntax:</p>
<div class="highlight-julia"><div class="highlight"><pre><span class="k">if</span> <span class="n">x</span> <span class="o"><</span> <span class="n">y</span>
<span class="n">println</span><span class="p">(</span><span class="s">"x is less than y"</span><span class="p">)</span>
<span class="k">elseif</span> <span class="n">x</span> <span class="o">></span> <span class="n">y</span>
<span class="n">println</span><span class="p">(</span><span class="s">"x is greater than y"</span><span class="p">)</span>
<span class="k">else</span>
<span class="n">println</span><span class="p">(</span><span class="s">"x is equal to y"</span><span class="p">)</span>
<span class="k">end</span>
</pre></div>
</div>
<p>If the condition expression <tt class="docutils literal"><span class="pre">x</span> <span class="pre"><</span> <span class="pre">y</span></tt> is <tt class="docutils literal"><span class="pre">true</span></tt>, then the corresponding block
is evaluated; otherwise the condition expression <tt class="docutils literal"><span class="pre">x</span> <span class="pre">></span> <span class="pre">y</span></tt> is evaluated, and if
it is <tt class="docutils literal"><span class="pre">true</span></tt>, the corresponding block is evaluated; if neither expression is
true, the <tt class="docutils literal"><span class="pre">else</span></tt> block is evaluated. Here it is in action:</p>
<div class="highlight-julia"><div class="highlight"><pre><span class="n">julia</span><span class="o">></span> <span class="k">function</span><span class="nf"> test</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">y</span><span class="p">)</span>
<span class="k">if</span> <span class="n">x</span> <span class="o"><</span> <span class="n">y</span>
<span class="n">println</span><span class="p">(</span><span class="s">"x is less than y"</span><span class="p">)</span>
<span class="k">elseif</span> <span class="n">x</span> <span class="o">></span> <span class="n">y</span>
<span class="n">println</span><span class="p">(</span><span class="s">"x is greater than y"</span><span class="p">)</span>
<span class="k">else</span>
<span class="n">println</span><span class="p">(</span><span class="s">"x is equal to y"</span><span class="p">)</span>
<span class="k">end</span>
<span class="k">end</span>
<span class="n">test</span> <span class="p">(</span><span class="n">generic</span> <span class="k">function</span><span class="nf"> with</span> <span class="mi">1</span> <span class="n">method</span><span class="p">)</span>
<span class="n">julia</span><span class="o">></span> <span class="n">test</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">)</span>
<span class="n">x</span> <span class="nb">is</span> <span class="n">less</span> <span class="n">than</span> <span class="n">y</span>
<span class="n">julia</span><span class="o">></span> <span class="n">test</span><span class="p">(</span><span class="mi">2</span><span class="p">,</span> <span class="mi">1</span><span class="p">)</span>
<span class="n">x</span> <span class="nb">is</span> <span class="n">greater</span> <span class="n">than</span> <span class="n">y</span>
<span class="n">julia</span><span class="o">></span> <span class="n">test</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">1</span><span class="p">)</span>
<span class="n">x</span> <span class="nb">is</span> <span class="n">equal</span> <span class="n">to</span> <span class="n">y</span>
</pre></div>
</div>
<p>The <tt class="docutils literal"><span class="pre">elseif</span></tt> and <tt class="docutils literal"><span class="pre">else</span></tt> blocks are optional, and as many <tt class="docutils literal"><span class="pre">elseif</span></tt>
blocks as desired can be used. The condition expressions in the
<tt class="docutils literal"><span class="pre">if</span></tt>-<tt class="docutils literal"><span class="pre">elseif</span></tt>-<tt class="docutils literal"><span class="pre">else</span></tt> construct are evaluated until the first one
evaluates to <tt class="docutils literal"><span class="pre">true</span></tt>, after which the associated block is evaluated,
and no further condition expressions or blocks are evaluated.</p>
<p>Note that very short conditional statements (one-liners) are frequently expressed using
Short-Circuit Evaluation in Julia, as outlined in the next section.</p>
<p>Unlike C, MATLAB, Perl, Python, and Ruby — but like Java, and a few
other stricter, typed languages — it is an error if the value of a
conditional expression is anything but <tt class="docutils literal"><span class="pre">true</span></tt> or <tt class="docutils literal"><span class="pre">false</span></tt>:</p>
<div class="highlight-julia"><div class="highlight"><pre><span class="n">julia</span><span class="o">></span> <span class="k">if</span> <span class="mi">1</span>
<span class="n">println</span><span class="p">(</span><span class="s">"true"</span><span class="p">)</span>
<span class="k">end</span>
<span class="n">ERROR</span><span class="p">:</span> <span class="n">type</span><span class="p">:</span> <span class="n">non</span><span class="o">-</span><span class="n">boolean</span> <span class="p">(</span><span class="kt">Int64</span><span class="p">)</span> <span class="n">used</span> <span class="k">in</span> <span class="n">boolean</span> <span class="n">context</span>
</pre></div>
</div>
<p>This error indicates that the conditional was of the wrong type:
<tt class="docutils literal"><span class="pre">Int64</span></tt> rather than the required <tt class="docutils literal"><span class="pre">Bool</span></tt>.</p>
<p>The so-called “ternary operator”, <tt class="docutils literal"><span class="pre">?:</span></tt>, is closely related to the
<tt class="docutils literal"><span class="pre">if</span></tt>-<tt class="docutils literal"><span class="pre">elseif</span></tt>-<tt class="docutils literal"><span class="pre">else</span></tt> syntax, but is used where a conditional
choice between single expression values is required, as opposed to
conditional execution of longer blocks of code. It gets its name from
being the only operator in most languages taking three operands:</p>
<div class="highlight-julia"><div class="highlight"><pre><span class="n">a</span> <span class="o">?</span> <span class="n">b</span> <span class="p">:</span> <span class="n">c</span>
</pre></div>
</div>
<p>The expression <tt class="docutils literal"><span class="pre">a</span></tt>, before the <tt class="docutils literal"><span class="pre">?</span></tt>, is a condition expression, and
the ternary operation evaluates the expression <tt class="docutils literal"><span class="pre">b</span></tt>, before the <tt class="docutils literal"><span class="pre">:</span></tt>,
if the condition <tt class="docutils literal"><span class="pre">a</span></tt> is <tt class="docutils literal"><span class="pre">true</span></tt> or the expression <tt class="docutils literal"><span class="pre">c</span></tt>, after the
<tt class="docutils literal"><span class="pre">:</span></tt>, if it is <tt class="docutils literal"><span class="pre">false</span></tt>.</p>
<p>The easiest way to understand this behavior is to see an example. In the
previous example, the <tt class="docutils literal"><span class="pre">println</span></tt> call is shared by all three branches:
the only real choice is which literal string to print. This could be
written more concisely using the ternary operator. For the sake of
clarity, let’s try a two-way version first:</p>
<div class="highlight-julia"><div class="highlight"><pre><span class="n">julia</span><span class="o">></span> <span class="n">x</span> <span class="o">=</span> <span class="mi">1</span><span class="p">;</span> <span class="n">y</span> <span class="o">=</span> <span class="mi">2</span><span class="p">;</span>
<span class="n">julia</span><span class="o">></span> <span class="n">println</span><span class="p">(</span><span class="n">x</span> <span class="o"><</span> <span class="n">y</span> <span class="o">?</span> <span class="s">"less than"</span> <span class="p">:</span> <span class="s">"not less than"</span><span class="p">)</span>
<span class="n">less</span> <span class="n">than</span>
<span class="n">julia</span><span class="o">></span> <span class="n">x</span> <span class="o">=</span> <span class="mi">1</span><span class="p">;</span> <span class="n">y</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span>
<span class="n">julia</span><span class="o">></span> <span class="n">println</span><span class="p">(</span><span class="n">x</span> <span class="o"><</span> <span class="n">y</span> <span class="o">?</span> <span class="s">"less than"</span> <span class="p">:</span> <span class="s">"not less than"</span><span class="p">)</span>
<span class="n">not</span> <span class="n">less</span> <span class="n">than</span>
</pre></div>
</div>
<p>If the expression <tt class="docutils literal"><span class="pre">x</span> <span class="pre"><</span> <span class="pre">y</span></tt> is true, the entire ternary operator
expression evaluates to the string <tt class="docutils literal"><span class="pre">"less</span> <span class="pre">than"</span></tt> and otherwise it
evaluates to the string <tt class="docutils literal"><span class="pre">"not</span> <span class="pre">less</span> <span class="pre">than"</span></tt>. The original three-way
example requires chaining multiple uses of the ternary operator
together:</p>
<div class="highlight-julia"><div class="highlight"><pre><span class="n">julia</span><span class="o">></span> <span class="n">test</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">y</span><span class="p">)</span> <span class="o">=</span> <span class="n">println</span><span class="p">(</span><span class="n">x</span> <span class="o"><</span> <span class="n">y</span> <span class="o">?</span> <span class="s">"x is less than y"</span> <span class="p">:</span>
<span class="n">x</span> <span class="o">></span> <span class="n">y</span> <span class="o">?</span> <span class="s">"x is greater than y"</span> <span class="p">:</span> <span class="s">"x is equal to y"</span><span class="p">)</span>
<span class="n">test</span> <span class="p">(</span><span class="n">generic</span> <span class="k">function</span><span class="nf"> with</span> <span class="mi">1</span> <span class="n">method</span><span class="p">)</span>
<span class="n">julia</span><span class="o">></span> <span class="n">test</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">)</span>
<span class="n">x</span> <span class="nb">is</span> <span class="n">less</span> <span class="n">than</span> <span class="n">y</span>
<span class="n">julia</span><span class="o">></span> <span class="n">test</span><span class="p">(</span><span class="mi">2</span><span class="p">,</span> <span class="mi">1</span><span class="p">)</span>
<span class="n">x</span> <span class="nb">is</span> <span class="n">greater</span> <span class="n">than</span> <span class="n">y</span>
<span class="n">julia</span><span class="o">></span> <span class="n">test</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">1</span><span class="p">)</span>
<span class="n">x</span> <span class="nb">is</span> <span class="n">equal</span> <span class="n">to</span> <span class="n">y</span>
</pre></div>
</div>
<p>To facilitate chaining, the operator associates from right to left.</p>
<p>It is significant that like <tt class="docutils literal"><span class="pre">if</span></tt>-<tt class="docutils literal"><span class="pre">elseif</span></tt>-<tt class="docutils literal"><span class="pre">else</span></tt>, the expressions
before and after the <tt class="docutils literal"><span class="pre">:</span></tt> are only evaluated if the condition
expression evaluates to <tt class="docutils literal"><span class="pre">true</span></tt> or <tt class="docutils literal"><span class="pre">false</span></tt>, respectively:</p>
<div class="highlight-julia"><div class="highlight"><pre><span class="n">julia</span><span class="o">></span> <span class="n">v</span><span class="p">(</span><span class="n">x</span><span class="p">)</span> <span class="o">=</span> <span class="p">(</span><span class="n">println</span><span class="p">(</span><span class="n">x</span><span class="p">);</span> <span class="n">x</span><span class="p">)</span>
<span class="n">v</span> <span class="p">(</span><span class="n">generic</span> <span class="k">function</span><span class="nf"> with</span> <span class="mi">1</span> <span class="n">method</span><span class="p">)</span>
<span class="n">julia</span><span class="o">></span> <span class="mi">1</span> <span class="o"><</span> <span class="mi">2</span> <span class="o">?</span> <span class="n">v</span><span class="p">(</span><span class="s">"yes"</span><span class="p">)</span> <span class="p">:</span> <span class="n">v</span><span class="p">(</span><span class="s">"no"</span><span class="p">)</span>
<span class="n">yes</span>
<span class="s">"yes"</span>
<span class="n">julia</span><span class="o">></span> <span class="mi">1</span> <span class="o">></span> <span class="mi">2</span> <span class="o">?</span> <span class="n">v</span><span class="p">(</span><span class="s">"yes"</span><span class="p">)</span> <span class="p">:</span> <span class="n">v</span><span class="p">(</span><span class="s">"no"</span><span class="p">)</span>
<span class="n">no</span>
<span class="s">"no"</span>
</pre></div>
</div>
</div>
<div class="section" id="short-circuit-evaluation">
<span id="man-short-circuit-evaluation"></span><h2>Short-Circuit Evaluation<a class="headerlink" href="#short-circuit-evaluation" title="Permalink to this headline">¶</a></h2>
<p>Short-circuit evaluation is quite similar to conditional evaluation. The
behavior is found in most imperative programming languages having the
<tt class="docutils literal"><span class="pre">&&</span></tt> and <tt class="docutils literal"><span class="pre">||</span></tt> boolean operators: in a series of boolean expressions
connected by these operators, only the minimum number of expressions are
evaluated as are necessary to determine the final boolean value of the
entire chain. Explicitly, this means that:</p>
<ul class="simple">
<li>In the expression <tt class="docutils literal"><span class="pre">a</span> <span class="pre">&&</span> <span class="pre">b</span></tt>, the subexpression <tt class="docutils literal"><span class="pre">b</span></tt> is only
evaluated if <tt class="docutils literal"><span class="pre">a</span></tt> evaluates to <tt class="docutils literal"><span class="pre">true</span></tt>.</li>
<li>In the expression <tt class="docutils literal"><span class="pre">a</span> <span class="pre">||</span> <span class="pre">b</span></tt>, the subexpression <tt class="docutils literal"><span class="pre">b</span></tt> is only
evaluated if <tt class="docutils literal"><span class="pre">a</span></tt> evaluates to <tt class="docutils literal"><span class="pre">false</span></tt>.</li>
</ul>
<p>The reasoning is that <tt class="docutils literal"><span class="pre">a</span> <span class="pre">&&</span> <span class="pre">b</span></tt> must be <tt class="docutils literal"><span class="pre">false</span></tt> if <tt class="docutils literal"><span class="pre">a</span></tt> is
<tt class="docutils literal"><span class="pre">false</span></tt>, regardless of the value of <tt class="docutils literal"><span class="pre">b</span></tt>, and likewise, the value of
<tt class="docutils literal"><span class="pre">a</span> <span class="pre">||</span> <span class="pre">b</span></tt> must be true if <tt class="docutils literal"><span class="pre">a</span></tt> is <tt class="docutils literal"><span class="pre">true</span></tt>, regardless of the value of
<tt class="docutils literal"><span class="pre">b</span></tt>. Both <tt class="docutils literal"><span class="pre">&&</span></tt> and <tt class="docutils literal"><span class="pre">||</span></tt> associate to the right, but <tt class="docutils literal"><span class="pre">&&</span></tt> has
higher precedence than <tt class="docutils literal"><span class="pre">||</span></tt> does. It’s easy to experiment with
this behavior:</p>
<div class="highlight-julia"><div class="highlight"><pre><span class="n">julia</span><span class="o">></span> <span class="n">t</span><span class="p">(</span><span class="n">x</span><span class="p">)</span> <span class="o">=</span> <span class="p">(</span><span class="n">println</span><span class="p">(</span><span class="n">x</span><span class="p">);</span> <span class="n">true</span><span class="p">)</span>
<span class="n">t</span> <span class="p">(</span><span class="n">generic</span> <span class="k">function</span><span class="nf"> with</span> <span class="mi">1</span> <span class="n">method</span><span class="p">)</span>
<span class="n">julia</span><span class="o">></span> <span class="n">f</span><span class="p">(</span><span class="n">x</span><span class="p">)</span> <span class="o">=</span> <span class="p">(</span><span class="n">println</span><span class="p">(</span><span class="n">x</span><span class="p">);</span> <span class="n">false</span><span class="p">)</span>
<span class="n">f</span> <span class="p">(</span><span class="n">generic</span> <span class="k">function</span><span class="nf"> with</span> <span class="mi">1</span> <span class="n">method</span><span class="p">)</span>
<span class="n">julia</span><span class="o">></span> <span class="n">t</span><span class="p">(</span><span class="mi">1</span><span class="p">)</span> <span class="o">&&</span> <span class="n">t</span><span class="p">(</span><span class="mi">2</span><span class="p">)</span>
<span class="mi">1</span>
<span class="mi">2</span>
<span class="n">true</span>
<span class="n">julia</span><span class="o">></span> <span class="n">t</span><span class="p">(</span><span class="mi">1</span><span class="p">)</span> <span class="o">&&</span> <span class="n">f</span><span class="p">(</span><span class="mi">2</span><span class="p">)</span>
<span class="mi">1</span>
<span class="mi">2</span>
<span class="n">false</span>
<span class="n">julia</span><span class="o">></span> <span class="n">f</span><span class="p">(</span><span class="mi">1</span><span class="p">)</span> <span class="o">&&</span> <span class="n">t</span><span class="p">(</span><span class="mi">2</span><span class="p">)</span>
<span class="mi">1</span>
<span class="n">false</span>
<span class="n">julia</span><span class="o">></span> <span class="n">f</span><span class="p">(</span><span class="mi">1</span><span class="p">)</span> <span class="o">&&</span> <span class="n">f</span><span class="p">(</span><span class="mi">2</span><span class="p">)</span>
<span class="mi">1</span>
<span class="n">false</span>
<span class="n">julia</span><span class="o">></span> <span class="n">t</span><span class="p">(</span><span class="mi">1</span><span class="p">)</span> <span class="o">||</span> <span class="n">t</span><span class="p">(</span><span class="mi">2</span><span class="p">)</span>
<span class="mi">1</span>
<span class="n">true</span>
<span class="n">julia</span><span class="o">></span> <span class="n">t</span><span class="p">(</span><span class="mi">1</span><span class="p">)</span> <span class="o">||</span> <span class="n">f</span><span class="p">(</span><span class="mi">2</span><span class="p">)</span>
<span class="mi">1</span>
<span class="n">true</span>
<span class="n">julia</span><span class="o">></span> <span class="n">f</span><span class="p">(</span><span class="mi">1</span><span class="p">)</span> <span class="o">||</span> <span class="n">t</span><span class="p">(</span><span class="mi">2</span><span class="p">)</span>
<span class="mi">1</span>
<span class="mi">2</span>
<span class="n">true</span>
<span class="n">julia</span><span class="o">></span> <span class="n">f</span><span class="p">(</span><span class="mi">1</span><span class="p">)</span> <span class="o">||</span> <span class="n">f</span><span class="p">(</span><span class="mi">2</span><span class="p">)</span>
<span class="mi">1</span>
<span class="mi">2</span>
<span class="n">false</span>
</pre></div>
</div>
<p>You can easily experiment in the same way with the associativity and
precedence of various combinations of <tt class="docutils literal"><span class="pre">&&</span></tt> and <tt class="docutils literal"><span class="pre">||</span></tt> operators.</p>
<p>This behavior is frequently used in Julia to form an alternative to very short
<tt class="docutils literal"><span class="pre">if</span></tt> statements. Instead of <tt class="docutils literal"><span class="pre">if</span> <span class="pre"><cond></span> <span class="pre"><statement></span> <span class="pre">end</span></tt>, one can write
<tt class="docutils literal"><span class="pre"><cond></span> <span class="pre">&&</span> <span class="pre"><statement></span></tt> (which could be read as: <cond> <em>and then</em> <statement>).
Similarly, instead of <tt class="docutils literal"><span class="pre">if</span> <span class="pre">!</span> <span class="pre"><cond></span> <span class="pre"><statement></span> <span class="pre">end</span></tt>, one can write
<tt class="docutils literal"><span class="pre"><cond></span> <span class="pre">||</span> <span class="pre"><statement></span></tt> (which could be read as: <cond> <em>or else</em> <statement>).</p>
<p>For example, a recursive factorial routine could be defined like this:</p>
<div class="highlight-julia"><div class="highlight"><pre><span class="n">julia</span><span class="o">></span> <span class="k">function</span><span class="nf"> factorial</span><span class="p">(</span><span class="n">n</span><span class="p">::</span><span class="kt">Int</span><span class="p">)</span>
<span class="n">n</span> <span class="o">>=</span> <span class="mi">0</span> <span class="o">||</span> <span class="nb">error</span><span class="p">(</span><span class="s">"n must be non-negative"</span><span class="p">)</span>
<span class="n">n</span> <span class="o">==</span> <span class="mi">0</span> <span class="o">&&</span> <span class="k">return</span> <span class="mi">1</span>
<span class="n">n</span> <span class="o">*</span> <span class="n">factorial</span><span class="p">(</span><span class="n">n</span><span class="o">-</span><span class="mi">1</span><span class="p">)</span>
<span class="k">end</span>
<span class="n">factorial</span> <span class="p">(</span><span class="n">generic</span> <span class="k">function</span><span class="nf"> with</span> <span class="mi">1</span> <span class="n">method</span><span class="p">)</span>
<span class="n">julia</span><span class="o">></span> <span class="n">factorial</span><span class="p">(</span><span class="mi">5</span><span class="p">)</span>
<span class="mi">120</span>
<span class="n">julia</span><span class="o">></span> <span class="n">factorial</span><span class="p">(</span><span class="mi">0</span><span class="p">)</span>
<span class="mi">1</span>
<span class="n">julia</span><span class="o">></span> <span class="n">factorial</span><span class="p">(</span><span class="o">-</span><span class="mi">1</span><span class="p">)</span>
<span class="n">ERROR</span><span class="p">:</span> <span class="n">n</span> <span class="n">must</span> <span class="n">be</span> <span class="n">non</span><span class="o">-</span><span class="n">negative</span>
<span class="k">in</span> <span class="n">factorial</span> <span class="n">at</span> <span class="n">none</span><span class="p">:</span><span class="mi">2</span>
</pre></div>
</div>
<p>Boolean operations <em>without</em> short-circuit evaluation can be done with the
bitwise boolean operators introduced in <a class="reference internal" href="mathematical-operations.html#man-mathematical-operations"><em>Mathematical Operations and Elementary Functions</em></a>:
<tt class="docutils literal"><span class="pre">&</span></tt> and <tt class="docutils literal"><span class="pre">|</span></tt>. These are normal functions, which happen to support
infix operator syntax, but always evaluate their arguments:</p>
<div class="highlight-julia"><div class="highlight"><pre><span class="n">julia</span><span class="o">></span> <span class="n">f</span><span class="p">(</span><span class="mi">1</span><span class="p">)</span> <span class="o">&</span> <span class="n">t</span><span class="p">(</span><span class="mi">2</span><span class="p">)</span>
<span class="mi">1</span>
<span class="mi">2</span>
<span class="n">false</span>
<span class="n">julia</span><span class="o">></span> <span class="n">t</span><span class="p">(</span><span class="mi">1</span><span class="p">)</span> <span class="o">|</span> <span class="n">t</span><span class="p">(</span><span class="mi">2</span><span class="p">)</span>
<span class="mi">1</span>
<span class="mi">2</span>
<span class="n">true</span>
</pre></div>
</div>
<p>Just like condition expressions used in <tt class="docutils literal"><span class="pre">if</span></tt>, <tt class="docutils literal"><span class="pre">elseif</span></tt> or the
ternary operator, the operands of <tt class="docutils literal"><span class="pre">&&</span></tt> or <tt class="docutils literal"><span class="pre">||</span></tt> must be boolean
values (<tt class="docutils literal"><span class="pre">true</span></tt> or <tt class="docutils literal"><span class="pre">false</span></tt>). Using a non-boolean value anywhere
except for the last entry in a conditional chain is an error:</p>
<div class="highlight-julia"><div class="highlight"><pre><span class="n">julia</span><span class="o">></span> <span class="mi">1</span> <span class="o">&&</span> <span class="n">true</span>
<span class="n">ERROR</span><span class="p">:</span> <span class="n">type</span><span class="p">:</span> <span class="n">non</span><span class="o">-</span><span class="n">boolean</span> <span class="p">(</span><span class="kt">Int64</span><span class="p">)</span> <span class="n">used</span> <span class="k">in</span> <span class="n">boolean</span> <span class="n">context</span>
</pre></div>
</div>
<p>On the other hand, any type of expression can be used at the end of a conditional chain.
It will be evaluated and returned depending on the preceding conditionals:</p>
<div class="highlight-julia"><div class="highlight"><pre><span class="n">julia</span><span class="o">></span> <span class="n">true</span> <span class="o">&&</span> <span class="p">(</span><span class="n">x</span> <span class="o">=</span> <span class="n">rand</span><span class="p">(</span><span class="mi">2</span><span class="p">,</span><span class="mi">2</span><span class="p">))</span>
<span class="mi">2</span><span class="n">x2</span> <span class="n">Array</span><span class="p">{</span><span class="kt">Float64</span><span class="p">,</span><span class="mi">2</span><span class="p">}:</span>
<span class="mf">0.768448</span> <span class="mf">0.673959</span>
<span class="mf">0.940515</span> <span class="mf">0.395453</span>
<span class="n">julia</span><span class="o">></span> <span class="n">false</span> <span class="o">&&</span> <span class="p">(</span><span class="n">x</span> <span class="o">=</span> <span class="n">rand</span><span class="p">(</span><span class="mi">2</span><span class="p">,</span><span class="mi">2</span><span class="p">))</span>
<span class="n">false</span>
</pre></div>
</div>
</div>
<div class="section" id="repeated-evaluation-loops">
<span id="man-loops"></span><h2>Repeated Evaluation: Loops<a class="headerlink" href="#repeated-evaluation-loops" title="Permalink to this headline">¶</a></h2>
<p>There are two constructs for repeated evaluation of expressions: the
<tt class="docutils literal"><span class="pre">while</span></tt> loop and the <tt class="docutils literal"><span class="pre">for</span></tt> loop. Here is an example of a <tt class="docutils literal"><span class="pre">while</span></tt>
loop:</p>
<div class="highlight-julia"><div class="highlight"><pre><span class="n">julia</span><span class="o">></span> <span class="n">i</span> <span class="o">=</span> <span class="mi">1</span><span class="p">;</span>
<span class="n">julia</span><span class="o">></span> <span class="k">while</span> <span class="n">i</span> <span class="o"><=</span> <span class="mi">5</span>
<span class="n">println</span><span class="p">(</span><span class="n">i</span><span class="p">)</span>
<span class="n">i</span> <span class="o">+=</span> <span class="mi">1</span>
<span class="k">end</span>
<span class="mi">1</span>
<span class="mi">2</span>
<span class="mi">3</span>
<span class="mi">4</span>
<span class="mi">5</span>
</pre></div>
</div>
<p>The <tt class="docutils literal"><span class="pre">while</span></tt> loop evaluates the condition expression (<tt class="docutils literal"><span class="pre">i</span> <span class="pre"><=</span> <span class="pre">5</span></tt> in this
case), and as long it remains <tt class="docutils literal"><span class="pre">true</span></tt>, keeps also evaluating the body
of the <tt class="docutils literal"><span class="pre">while</span></tt> loop. If the condition expression is <tt class="docutils literal"><span class="pre">false</span></tt> when the
<tt class="docutils literal"><span class="pre">while</span></tt> loop is first reached, the body is never evaluated.</p>
<p>The <tt class="docutils literal"><span class="pre">for</span></tt> loop makes common repeated evaluation idioms easier to
write. Since counting up and down like the above <tt class="docutils literal"><span class="pre">while</span></tt> loop does is
so common, it can be expressed more concisely with a <tt class="docutils literal"><span class="pre">for</span></tt> loop:</p>
<div class="highlight-julia"><div class="highlight"><pre><span class="n">julia</span><span class="o">></span> <span class="k">for</span> <span class="n">i</span> <span class="o">=</span> <span class="mi">1</span><span class="p">:</span><span class="mi">5</span>
<span class="n">println</span><span class="p">(</span><span class="n">i</span><span class="p">)</span>
<span class="k">end</span>
<span class="mi">1</span>
<span class="mi">2</span>
<span class="mi">3</span>
<span class="mi">4</span>
<span class="mi">5</span>
</pre></div>
</div>
<p>Here the <tt class="docutils literal"><span class="pre">1:5</span></tt> is a <tt class="docutils literal"><span class="pre">Range</span></tt> object, representing the sequence of
numbers 1, 2, 3, 4, 5. The <tt class="docutils literal"><span class="pre">for</span></tt> loop iterates through these values,
assigning each one in turn to the variable <tt class="docutils literal"><span class="pre">i</span></tt>. One rather important
distinction between the previous <tt class="docutils literal"><span class="pre">while</span></tt> loop form and the <tt class="docutils literal"><span class="pre">for</span></tt>
loop form is the scope during which the variable is visible. If the
variable <tt class="docutils literal"><span class="pre">i</span></tt> has not been introduced in an other scope, in the <tt class="docutils literal"><span class="pre">for</span></tt>
loop form, it is visible only inside of the <tt class="docutils literal"><span class="pre">for</span></tt> loop, and not
afterwards. You’ll either need a new interactive session instance or a
different variable name to test this:</p>
<div class="highlight-julia"><div class="highlight"><pre><span class="n">julia</span><span class="o">></span> <span class="k">for</span> <span class="n">j</span> <span class="o">=</span> <span class="mi">1</span><span class="p">:</span><span class="mi">5</span>
<span class="n">println</span><span class="p">(</span><span class="n">j</span><span class="p">)</span>
<span class="k">end</span>
<span class="mi">1</span>
<span class="mi">2</span>
<span class="mi">3</span>
<span class="mi">4</span>
<span class="mi">5</span>
<span class="n">julia</span><span class="o">></span> <span class="n">j</span>
<span class="n">ERROR</span><span class="p">:</span> <span class="n">j</span> <span class="n">not</span> <span class="n">defined</span>
</pre></div>
</div>
<p>See <a class="reference internal" href="variables-and-scoping.html#man-variables-and-scoping"><em>Scope of Variables</em></a> for a detailed
explanation of variable scope and how it works in Julia.</p>
<p>In general, the <tt class="docutils literal"><span class="pre">for</span></tt> loop construct can iterate over any container.
In these cases, the alternative (but fully equivalent) keyword <tt class="docutils literal"><span class="pre">in</span></tt> is
typically used instead of <tt class="docutils literal"><span class="pre">=</span></tt>, since it makes the code read more
clearly:</p>
<div class="highlight-julia"><div class="highlight"><pre><span class="n">julia</span><span class="o">></span> <span class="k">for</span> <span class="n">i</span> <span class="k">in</span> <span class="p">[</span><span class="mi">1</span><span class="p">,</span><span class="mi">4</span><span class="p">,</span><span class="mi">0</span><span class="p">]</span>
<span class="n">println</span><span class="p">(</span><span class="n">i</span><span class="p">)</span>
<span class="k">end</span>
<span class="mi">1</span>
<span class="mi">4</span>
<span class="mi">0</span>
<span class="n">julia</span><span class="o">></span> <span class="k">for</span> <span class="n">s</span> <span class="k">in</span> <span class="p">[</span><span class="s">"foo"</span><span class="p">,</span><span class="s">"bar"</span><span class="p">,</span><span class="s">"baz"</span><span class="p">]</span>
<span class="n">println</span><span class="p">(</span><span class="n">s</span><span class="p">)</span>
<span class="k">end</span>
<span class="n">foo</span>
<span class="n">bar</span>
<span class="n">baz</span>
</pre></div>
</div>
<p>Various types of iterable containers will be introduced and discussed in
later sections of the manual (see, e.g., <a class="reference internal" href="arrays.html#man-arrays"><em>Multi-dimensional Arrays</em></a>).</p>
<p>It is sometimes convenient to terminate the repetition of a <tt class="docutils literal"><span class="pre">while</span></tt>
before the test condition is falsified or stop iterating in a <tt class="docutils literal"><span class="pre">for</span></tt>
loop before the end of the iterable object is reached. This can be
accomplished with the <tt class="docutils literal"><span class="pre">break</span></tt> keyword:</p>
<div class="highlight-julia"><div class="highlight"><pre><span class="n">julia</span><span class="o">></span> <span class="n">i</span> <span class="o">=</span> <span class="mi">1</span><span class="p">;</span>
<span class="n">julia</span><span class="o">></span> <span class="k">while</span> <span class="n">true</span>
<span class="n">println</span><span class="p">(</span><span class="n">i</span><span class="p">)</span>
<span class="k">if</span> <span class="n">i</span> <span class="o">>=</span> <span class="mi">5</span>
<span class="k">break</span>
<span class="k">end</span>
<span class="n">i</span> <span class="o">+=</span> <span class="mi">1</span>
<span class="k">end</span>
<span class="mi">1</span>
<span class="mi">2</span>
<span class="mi">3</span>
<span class="mi">4</span>
<span class="mi">5</span>
<span class="n">julia</span><span class="o">></span> <span class="k">for</span> <span class="n">i</span> <span class="o">=</span> <span class="mi">1</span><span class="p">:</span><span class="mi">1000</span>
<span class="n">println</span><span class="p">(</span><span class="n">i</span><span class="p">)</span>
<span class="k">if</span> <span class="n">i</span> <span class="o">>=</span> <span class="mi">5</span>
<span class="k">break</span>
<span class="k">end</span>
<span class="k">end</span>
<span class="mi">1</span>
<span class="mi">2</span>
<span class="mi">3</span>
<span class="mi">4</span>
<span class="mi">5</span>
</pre></div>
</div>
<p>The above <tt class="docutils literal"><span class="pre">while</span></tt> loop would never terminate on its own, and the
<tt class="docutils literal"><span class="pre">for</span></tt> loop would iterate up to 1000. These loops are both exited early
by using the <tt class="docutils literal"><span class="pre">break</span></tt> keyword.</p>
<p>In other circumstances, it is handy to be able to stop an iteration and
move on to the next one immediately. The <tt class="docutils literal"><span class="pre">continue</span></tt> keyword
accomplishes this:</p>
<div class="highlight-julia"><div class="highlight"><pre><span class="n">julia</span><span class="o">></span> <span class="k">for</span> <span class="n">i</span> <span class="o">=</span> <span class="mi">1</span><span class="p">:</span><span class="mi">10</span>
<span class="k">if</span> <span class="n">i</span> <span class="o">%</span> <span class="mi">3</span> <span class="o">!=</span> <span class="mi">0</span>
<span class="k">continue</span>
<span class="k">end</span>
<span class="n">println</span><span class="p">(</span><span class="n">i</span><span class="p">)</span>
<span class="k">end</span>
<span class="mi">3</span>
<span class="mi">6</span>
<span class="mi">9</span>
</pre></div>
</div>
<p>This is a somewhat contrived example since we could produce the same
behavior more clearly by negating the condition and placing the
<tt class="docutils literal"><span class="pre">println</span></tt> call inside the <tt class="docutils literal"><span class="pre">if</span></tt> block. In realistic usage there is
more code to be evaluated after the <tt class="docutils literal"><span class="pre">continue</span></tt>, and often there are
multiple points from which one calls <tt class="docutils literal"><span class="pre">continue</span></tt>.</p>
<p>Multiple nested <tt class="docutils literal"><span class="pre">for</span></tt> loops can be combined into a single outer loop,
forming the cartesian product of its iterables:</p>
<div class="highlight-julia"><div class="highlight"><pre><span class="n">julia</span><span class="o">></span> <span class="k">for</span> <span class="n">i</span> <span class="o">=</span> <span class="mi">1</span><span class="p">:</span><span class="mi">2</span><span class="p">,</span> <span class="n">j</span> <span class="o">=</span> <span class="mi">3</span><span class="p">:</span><span class="mi">4</span>
<span class="n">println</span><span class="p">((</span><span class="n">i</span><span class="p">,</span> <span class="n">j</span><span class="p">))</span>
<span class="k">end</span>
<span class="p">(</span><span class="mi">1</span><span class="p">,</span><span class="mi">3</span><span class="p">)</span>
<span class="p">(</span><span class="mi">1</span><span class="p">,</span><span class="mi">4</span><span class="p">)</span>
<span class="p">(</span><span class="mi">2</span><span class="p">,</span><span class="mi">3</span><span class="p">)</span>
<span class="p">(</span><span class="mi">2</span><span class="p">,</span><span class="mi">4</span><span class="p">)</span>
</pre></div>
</div>
<p>A <tt class="docutils literal"><span class="pre">break</span></tt> statement inside such a loop exits the entire nest of loops,
not just the inner one.</p>
</div>
<div class="section" id="exception-handling">
<span id="man-exception-handling"></span><h2>Exception Handling<a class="headerlink" href="#exception-handling" title="Permalink to this headline">¶</a></h2>
<p>When an unexpected condition occurs, a function may be unable to return
a reasonable value to its caller. In such cases, it may be best for the
exceptional condition to either terminate the program, printing a
diagnostic error message, or if the programmer has provided code to
handle such exceptional circumstances, allow that code to take the
appropriate action.</p>
<div class="section" id="built-in-exceptions">
<h3>Built-in <tt class="docutils literal"><span class="pre">Exception</span></tt>s<a class="headerlink" href="#built-in-exceptions" title="Permalink to this headline">¶</a></h3>
<p><tt class="docutils literal"><span class="pre">Exception</span></tt>s are thrown when an unexpected condition has occurred. The
built-in <tt class="docutils literal"><span class="pre">Exception</span></tt>s listed below all interrupt the normal flow of control.</p>
<table border="1" class="docutils">
<colgroup>
<col width="100%" />
</colgroup>
<thead valign="bottom">
<tr class="row-odd"><th class="head"><tt class="docutils literal"><span class="pre">Exception</span></tt></th>
</tr>
</thead>
<tbody valign="top">
<tr class="row-even"><td><tt class="docutils literal"><span class="pre">ArgumentError</span></tt></td>
</tr>
<tr class="row-odd"><td><tt class="docutils literal"><span class="pre">BoundsError</span></tt></td>
</tr>
<tr class="row-even"><td><tt class="docutils literal"><span class="pre">DivideError</span></tt></td>
</tr>
<tr class="row-odd"><td><tt class="docutils literal"><span class="pre">DomainError</span></tt></td>
</tr>
<tr class="row-even"><td><tt class="docutils literal"><span class="pre">EOFError</span></tt></td>
</tr>
<tr class="row-odd"><td><tt class="docutils literal"><span class="pre">ErrorException</span></tt></td>
</tr>
<tr class="row-even"><td><tt class="docutils literal"><span class="pre">InexactError</span></tt></td>
</tr>
<tr class="row-odd"><td><tt class="docutils literal"><span class="pre">InterruptException</span></tt></td>
</tr>
<tr class="row-even"><td><tt class="docutils literal"><span class="pre">KeyError</span></tt></td>
</tr>
<tr class="row-odd"><td><tt class="docutils literal"><span class="pre">LoadError</span></tt></td>
</tr>
<tr class="row-even"><td><tt class="docutils literal"><span class="pre">MemoryError</span></tt></td>
</tr>
<tr class="row-odd"><td><tt class="docutils literal"><span class="pre">MethodError</span></tt></td>
</tr>
<tr class="row-even"><td><tt class="docutils literal"><span class="pre">OverflowError</span></tt></td>
</tr>
<tr class="row-odd"><td><tt class="docutils literal"><span class="pre">ParseError</span></tt></td>
</tr>
<tr class="row-even"><td><tt class="docutils literal"><span class="pre">SystemError</span></tt></td>
</tr>
<tr class="row-odd"><td><tt class="docutils literal"><span class="pre">TypeError</span></tt></td>
</tr>
<tr class="row-even"><td><tt class="docutils literal"><span class="pre">UndefRefError</span></tt></td>
</tr>
<tr class="row-odd"><td><tt class="docutils literal"><span class="pre">UndefVarError</span></tt></td>
</tr>
</tbody>
</table>
<p>For example, the <tt class="docutils literal"><span class="pre">sqrt</span></tt> function throws a <tt class="docutils literal"><span class="pre">DomainError()</span></tt> if applied to a
negative real value:</p>
<div class="highlight-julia"><div class="highlight"><pre><span class="n">julia</span><span class="o">></span> <span class="n">sqrt</span><span class="p">(</span><span class="o">-</span><span class="mi">1</span><span class="p">)</span>
<span class="n">ERROR</span><span class="p">:</span> <span class="n">DomainError</span>
<span class="n">sqrt</span> <span class="n">will</span> <span class="n">only</span> <span class="k">return</span> <span class="n">a</span> <span class="n">complex</span> <span class="n">result</span> <span class="k">if</span> <span class="n">called</span> <span class="n">with</span> <span class="n">a</span> <span class="n">complex</span> <span class="n">argument</span><span class="o">.</span>
<span class="k">try</span> <span class="n">sqrt</span><span class="p">(</span><span class="n">complex</span><span class="p">(</span><span class="n">x</span><span class="p">))</span>
<span class="k">in</span> <span class="n">sqrt</span> <span class="n">at</span> <span class="n">math</span><span class="o">.</span><span class="n">jl</span><span class="p">:</span><span class="mi">131</span>
</pre></div>
</div>
<p>You may define your own exceptions in the following way:</p>
<div class="highlight-julia"><div class="highlight"><pre><span class="n">julia</span><span class="o">></span> <span class="k">type</span><span class="nc"> MyCustomException</span> <span class="o"><:</span> <span class="n">Exception</span> <span class="k">end</span>
</pre></div>
</div>
</div>
<div class="section" id="the-throw-function">
<h3>The <tt class="docutils literal"><span class="pre">throw</span></tt> function<a class="headerlink" href="#the-throw-function" title="Permalink to this headline">¶</a></h3>
<p>Exceptions can be created explicitly with <tt class="docutils literal"><span class="pre">throw</span></tt>. For example, a function
defined only for nonnegative numbers could be written to <tt class="docutils literal"><span class="pre">throw</span></tt> a <tt class="docutils literal"><span class="pre">DomainError</span></tt>
if the argument is negative:</p>
<div class="highlight-julia"><div class="highlight"><pre><span class="n">julia</span><span class="o">></span> <span class="n">f</span><span class="p">(</span><span class="n">x</span><span class="p">)</span> <span class="o">=</span> <span class="n">x</span><span class="o">>=</span><span class="mi">0</span> <span class="o">?</span> <span class="n">exp</span><span class="p">(</span><span class="o">-</span><span class="n">x</span><span class="p">)</span> <span class="p">:</span> <span class="nb">throw</span><span class="p">(</span><span class="n">DomainError</span><span class="p">())</span>
<span class="n">f</span> <span class="p">(</span><span class="n">generic</span> <span class="k">function</span><span class="nf"> with</span> <span class="mi">1</span> <span class="n">method</span><span class="p">)</span>
<span class="n">julia</span><span class="o">></span> <span class="n">f</span><span class="p">(</span><span class="mi">1</span><span class="p">)</span>
<span class="mf">0.36787944117144233</span>
<span class="n">julia</span><span class="o">></span> <span class="n">f</span><span class="p">(</span><span class="o">-</span><span class="mi">1</span><span class="p">)</span>
<span class="n">ERROR</span><span class="p">:</span> <span class="n">DomainError</span>
<span class="k">in</span> <span class="n">f</span> <span class="n">at</span> <span class="n">none</span><span class="p">:</span><span class="mi">1</span>
</pre></div>
</div>
<p>Note that <tt class="docutils literal"><span class="pre">DomainError</span></tt> without parentheses is not an exception, but a type of
exception. It needs to be called to obtain an <tt class="docutils literal"><span class="pre">Exception</span></tt> object:</p>
<div class="highlight-julia"><div class="highlight"><pre><span class="n">julia</span><span class="o">></span> <span class="nb">typeof</span><span class="p">(</span><span class="n">DomainError</span><span class="p">())</span> <span class="o"><:</span> <span class="n">Exception</span>
<span class="n">true</span>
<span class="n">julia</span><span class="o">></span> <span class="nb">typeof</span><span class="p">(</span><span class="n">DomainError</span><span class="p">)</span> <span class="o"><:</span> <span class="n">Exception</span>
<span class="n">false</span>
</pre></div>
</div>
<p>Additionally, some exception types take one or more arguments that are used for
error reporting:</p>
<div class="highlight-julia"><div class="highlight"><pre><span class="n">julia</span><span class="o">></span> <span class="nb">throw</span><span class="p">(</span><span class="n">UndefVarError</span><span class="p">(:</span><span class="n">x</span><span class="p">))</span>
<span class="n">ERROR</span><span class="p">:</span> <span class="n">x</span> <span class="n">not</span> <span class="n">defined</span>
</pre></div>
</div>
<p>This mechanism can be implemented easily by custom exception types following
the way <tt class="docutils literal"><span class="pre">UndefVarError</span></tt> is written:</p>
<div class="highlight-julia"><div class="highlight"><pre><span class="n">julia</span><span class="o">></span> <span class="k">type</span><span class="nc"> MyUndefVarError</span> <span class="o"><:</span> <span class="n">Exception</span>
<span class="n">var</span><span class="p">::</span><span class="n">Symbol</span>
<span class="k">end</span>
<span class="n">julia</span><span class="o">></span> <span class="n">Base</span><span class="o">.</span><span class="n">showerror</span><span class="p">(</span><span class="n">io</span><span class="p">::</span><span class="n">IO</span><span class="p">,</span> <span class="n">e</span><span class="p">::</span><span class="n">MyUndefVarError</span><span class="p">)</span> <span class="o">=</span> <span class="n">print</span><span class="p">(</span><span class="n">io</span><span class="p">,</span> <span class="n">e</span><span class="o">.</span><span class="n">var</span><span class="p">,</span> <span class="s">" not defined"</span><span class="p">);</span>
</pre></div>
</div>
</div>
<div class="section" id="errors">
<h3>Errors<a class="headerlink" href="#errors" title="Permalink to this headline">¶</a></h3>
<p>The <tt class="docutils literal"><span class="pre">error</span></tt> function is used to produce an <tt class="docutils literal"><span class="pre">ErrorException</span></tt> that
interrupts the normal flow of control.</p>
<p>Suppose we want to stop execution immediately if the square root of a
negative number is taken. To do this, we can define a fussy version of
the <tt class="docutils literal"><span class="pre">sqrt</span></tt> function that raises an error if its argument is negative:</p>
<div class="highlight-julia"><div class="highlight"><pre><span class="n">julia</span><span class="o">></span> <span class="n">fussy_sqrt</span><span class="p">(</span><span class="n">x</span><span class="p">)</span> <span class="o">=</span> <span class="n">x</span> <span class="o">>=</span> <span class="mi">0</span> <span class="o">?</span> <span class="n">sqrt</span><span class="p">(</span><span class="n">x</span><span class="p">)</span> <span class="p">:</span> <span class="nb">error</span><span class="p">(</span><span class="s">"negative x not allowed"</span><span class="p">)</span>
<span class="n">fussy_sqrt</span> <span class="p">(</span><span class="n">generic</span> <span class="k">function</span><span class="nf"> with</span> <span class="mi">1</span> <span class="n">method</span><span class="p">)</span>
<span class="n">julia</span><span class="o">></span> <span class="n">fussy_sqrt</span><span class="p">(</span><span class="mi">2</span><span class="p">)</span>
<span class="mf">1.4142135623730951</span>
<span class="n">julia</span><span class="o">></span> <span class="n">fussy_sqrt</span><span class="p">(</span><span class="o">-</span><span class="mi">1</span><span class="p">)</span>
<span class="n">ERROR</span><span class="p">:</span> <span class="n">negative</span> <span class="n">x</span> <span class="n">not</span> <span class="n">allowed</span>
<span class="k">in</span> <span class="n">fussy_sqrt</span> <span class="n">at</span> <span class="n">none</span><span class="p">:</span><span class="mi">1</span>
</pre></div>
</div>
<p>If <tt class="docutils literal"><span class="pre">fussy_sqrt</span></tt> is called with a negative value from another function,
instead of trying to continue execution of the calling function, it
returns immediately, displaying the error message in the interactive
session:</p>
<div class="highlight-julia"><div class="highlight"><pre><span class="n">julia</span><span class="o">></span> <span class="k">function</span><span class="nf"> verbose_fussy_sqrt</span><span class="p">(</span><span class="n">x</span><span class="p">)</span>
<span class="n">println</span><span class="p">(</span><span class="s">"before fussy_sqrt"</span><span class="p">)</span>
<span class="n">r</span> <span class="o">=</span> <span class="n">fussy_sqrt</span><span class="p">(</span><span class="n">x</span><span class="p">)</span>
<span class="n">println</span><span class="p">(</span><span class="s">"after fussy_sqrt"</span><span class="p">)</span>
<span class="k">return</span> <span class="n">r</span>
<span class="k">end</span>
<span class="n">verbose_fussy_sqrt</span> <span class="p">(</span><span class="n">generic</span> <span class="k">function</span><span class="nf"> with</span> <span class="mi">1</span> <span class="n">method</span><span class="p">)</span>
<span class="n">julia</span><span class="o">></span> <span class="n">verbose_fussy_sqrt</span><span class="p">(</span><span class="mi">2</span><span class="p">)</span>
<span class="n">before</span> <span class="n">fussy_sqrt</span>
<span class="n">after</span> <span class="n">fussy_sqrt</span>
<span class="mf">1.4142135623730951</span>
<span class="n">julia</span><span class="o">></span> <span class="n">verbose_fussy_sqrt</span><span class="p">(</span><span class="o">-</span><span class="mi">1</span><span class="p">)</span>
<span class="n">before</span> <span class="n">fussy_sqrt</span>
<span class="n">ERROR</span><span class="p">:</span> <span class="n">negative</span> <span class="n">x</span> <span class="n">not</span> <span class="n">allowed</span>
<span class="k">in</span> <span class="n">verbose_fussy_sqrt</span> <span class="n">at</span> <span class="n">none</span><span class="p">:</span><span class="mi">3</span>
</pre></div>
</div>
</div>
<div class="section" id="warnings-and-informational-messages">
<h3>Warnings and informational messages<a class="headerlink" href="#warnings-and-informational-messages" title="Permalink to this headline">¶</a></h3>
<p>Julia also provides other functions that write messages to the standard error
I/O, but do not throw any <tt class="docutils literal"><span class="pre">Exception</span></tt>s and hence do not interrupt
execution.:</p>
<div class="highlight-julia"><div class="highlight"><pre><span class="n">julia</span><span class="o">></span> <span class="n">info</span><span class="p">(</span><span class="s">"Hi"</span><span class="p">);</span> <span class="mi">1</span><span class="o">+</span><span class="mi">1</span>
<span class="n">INFO</span><span class="p">:</span> <span class="n">Hi</span>
<span class="mi">2</span>
<span class="n">julia</span><span class="o">></span> <span class="n">warn</span><span class="p">(</span><span class="s">"Hi"</span><span class="p">);</span> <span class="mi">1</span><span class="o">+</span><span class="mi">1</span>
<span class="n">WARNING</span><span class="p">:</span> <span class="n">Hi</span>
<span class="mi">2</span>
<span class="n">julia</span><span class="o">></span> <span class="nb">error</span><span class="p">(</span><span class="s">"Hi"</span><span class="p">);</span> <span class="mi">1</span><span class="o">+</span><span class="mi">1</span>
<span class="n">ERROR</span><span class="p">:</span> <span class="n">Hi</span>
<span class="k">in</span> <span class="nb">error</span> <span class="n">at</span> <span class="nb">error</span><span class="o">.</span><span class="n">jl</span><span class="p">:</span><span class="mi">21</span>
</pre></div>
</div>
</div>
<div class="section" id="the-try-catch-statement">
<h3>The <tt class="docutils literal"><span class="pre">try/catch</span></tt> statement<a class="headerlink" href="#the-try-catch-statement" title="Permalink to this headline">¶</a></h3>
<p>The <tt class="docutils literal"><span class="pre">try/catch</span></tt> statement allows for <tt class="docutils literal"><span class="pre">Exception</span></tt>s to be tested for. For
example, a customized square root function can be written to automatically
call either the real or complex square root method on demand using
<tt class="docutils literal"><span class="pre">Exception</span></tt>s :</p>
<div class="highlight-julia"><div class="highlight"><pre><span class="n">julia</span><span class="o">></span> <span class="n">f</span><span class="p">(</span><span class="n">x</span><span class="p">)</span> <span class="o">=</span> <span class="k">try</span>
<span class="n">sqrt</span><span class="p">(</span><span class="n">x</span><span class="p">)</span>
<span class="k">catch</span>
<span class="n">sqrt</span><span class="p">(</span><span class="n">complex</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="mi">0</span><span class="p">))</span>
<span class="k">end</span>
<span class="n">f</span> <span class="p">(</span><span class="n">generic</span> <span class="k">function</span><span class="nf"> with</span> <span class="mi">1</span> <span class="n">method</span><span class="p">)</span>
<span class="n">julia</span><span class="o">></span> <span class="n">f</span><span class="p">(</span><span class="mi">1</span><span class="p">)</span>
<span class="mf">1.0</span>
<span class="n">julia</span><span class="o">></span> <span class="n">f</span><span class="p">(</span><span class="o">-</span><span class="mi">1</span><span class="p">)</span>
<span class="mf">0.0</span> <span class="o">+</span> <span class="mf">1.0</span><span class="nb">im</span>
</pre></div>
</div>
<p>It is important to note that in real code computing this function, one would
compare <tt class="docutils literal"><span class="pre">x</span></tt> to zero instead of catching an exception. The exception is much
slower than simply comparing and branching.</p>
<p><tt class="docutils literal"><span class="pre">try/catch</span></tt> statements also allow the <tt class="docutils literal"><span class="pre">Exception</span></tt> to be saved in a
variable. In this contrived example, the following example calculates the
square root of the second element of <tt class="docutils literal"><span class="pre">x</span></tt> if <tt class="docutils literal"><span class="pre">x</span></tt> is indexable, otherwise
assumes <tt class="docutils literal"><span class="pre">x</span></tt> is a real number and returns its square root:</p>
<div class="highlight-julia"><div class="highlight"><pre><span class="n">julia</span><span class="o">></span> <span class="n">sqrt_second</span><span class="p">(</span><span class="n">x</span><span class="p">)</span> <span class="o">=</span> <span class="k">try</span>
<span class="n">sqrt</span><span class="p">(</span><span class="n">x</span><span class="p">[</span><span class="mi">2</span><span class="p">])</span>
<span class="k">catch</span> <span class="n">y</span>
<span class="k">if</span> <span class="nb">isa</span><span class="p">(</span><span class="n">y</span><span class="p">,</span> <span class="n">DomainError</span><span class="p">)</span>
<span class="n">sqrt</span><span class="p">(</span><span class="n">complex</span><span class="p">(</span><span class="n">x</span><span class="p">[</span><span class="mi">2</span><span class="p">],</span> <span class="mi">0</span><span class="p">))</span>
<span class="k">elseif</span> <span class="nb">isa</span><span class="p">(</span><span class="n">y</span><span class="p">,</span> <span class="n">BoundsError</span><span class="p">)</span>
<span class="n">sqrt</span><span class="p">(</span><span class="n">x</span><span class="p">)</span>
<span class="k">end</span>
<span class="k">end</span>
<span class="n">sqrt_second</span> <span class="p">(</span><span class="n">generic</span> <span class="k">function</span><span class="nf"> with</span> <span class="mi">1</span> <span class="n">method</span><span class="p">)</span>
<span class="n">julia</span><span class="o">></span> <span class="n">sqrt_second</span><span class="p">([</span><span class="mi">1</span> <span class="mi">4</span><span class="p">])</span>
<span class="mf">2.0</span>
<span class="n">julia</span><span class="o">></span> <span class="n">sqrt_second</span><span class="p">([</span><span class="mi">1</span> <span class="o">-</span><span class="mi">4</span><span class="p">])</span>
<span class="mf">0.0</span> <span class="o">+</span> <span class="mf">2.0</span><span class="nb">im</span>
<span class="n">julia</span><span class="o">></span> <span class="n">sqrt_second</span><span class="p">(</span><span class="mi">9</span><span class="p">)</span>
<span class="mf">3.0</span>
<span class="n">julia</span><span class="o">></span> <span class="n">sqrt_second</span><span class="p">(</span><span class="o">-</span><span class="mi">9</span><span class="p">)</span>
<span class="n">ERROR</span><span class="p">:</span> <span class="n">DomainError</span>
<span class="k">in</span> <span class="n">sqrt_second</span> <span class="n">at</span> <span class="n">none</span><span class="p">:</span><span class="mi">7</span>
</pre></div>
</div>
<p>Note that the symbol following <tt class="docutils literal"><span class="pre">catch</span></tt> will always be interpreted as a
name for the exception, so care is needed when writing <tt class="docutils literal"><span class="pre">try/catch</span></tt> expressions
on a single line. The following code will <em>not</em> work to return the value of <tt class="docutils literal"><span class="pre">x</span></tt>
in case of an error:</p>
<div class="highlight-julia"><div class="highlight"><pre><span class="k">try</span> <span class="n">bad</span><span class="p">()</span> <span class="k">catch</span> <span class="n">x</span> <span class="k">end</span>
</pre></div>
</div>
<p>Instead, use a semicolon or insert a line break after <tt class="docutils literal"><span class="pre">catch</span></tt>:</p>
<div class="highlight-julia"><div class="highlight"><pre><span class="k">try</span> <span class="n">bad</span><span class="p">()</span> <span class="k">catch</span><span class="p">;</span> <span class="n">x</span> <span class="k">end</span>
<span class="k">try</span> <span class="n">bad</span><span class="p">()</span>
<span class="k">catch</span>
<span class="n">x</span>
<span class="k">end</span>
</pre></div>
</div>
<p>The power of the <tt class="docutils literal"><span class="pre">try/catch</span></tt> construct lies in the ability to unwind a deeply
nested computation immediately to a much higher level in the stack of calling
functions. There are situations where no error has occurred, but the ability to
unwind the stack and pass a value to a higher level is desirable. Julia
provides the <tt class="docutils literal"><span class="pre">rethrow</span></tt>, <tt class="docutils literal"><span class="pre">backtrace</span></tt> and <tt class="docutils literal"><span class="pre">catch_backtrace</span></tt> functions for
more advanced error handling.</p>
</div>
<div class="section" id="finally-clauses">
<h3>finally Clauses<a class="headerlink" href="#finally-clauses" title="Permalink to this headline">¶</a></h3>
<p>In code that performs state changes or uses resources like files, there is
typically clean-up work (such as closing files) that needs to be done when the
code is finished. Exceptions potentially complicate this task, since they can
cause a block of code to exit before reaching its normal end. The <tt class="docutils literal"><span class="pre">finally</span></tt>
keyword provides a way to run some code when a given block of code exits,
regardless of how it exits.</p>
<p>For example, here is how we can guarantee that an opened file is closed:</p>
<div class="highlight-julia"><div class="highlight"><pre><span class="n">f</span> <span class="o">=</span> <span class="n">open</span><span class="p">(</span><span class="s">"file"</span><span class="p">)</span>
<span class="k">try</span>
<span class="c"># operate on file f</span>
<span class="n">finally</span>
<span class="n">close</span><span class="p">(</span><span class="n">f</span><span class="p">)</span>
<span class="k">end</span>
</pre></div>
</div>
<p>When control leaves the <tt class="docutils literal"><span class="pre">try</span></tt> block (for example due to a <tt class="docutils literal"><span class="pre">return</span></tt>, or
just finishing normally), <tt class="docutils literal"><span class="pre">close(f)</span></tt> will be executed. If
the <tt class="docutils literal"><span class="pre">try</span></tt> block exits due to an exception, the exception will continue
propagating. A <tt class="docutils literal"><span class="pre">catch</span></tt> block may be combined with <tt class="docutils literal"><span class="pre">try</span></tt> and <tt class="docutils literal"><span class="pre">finally</span></tt>
as well. In this case the <tt class="docutils literal"><span class="pre">finally</span></tt> block will run after <tt class="docutils literal"><span class="pre">catch</span></tt> has
handled the error.</p>
</div>
</div>
<div class="section" id="tasks-aka-coroutines">
<span id="man-tasks"></span><h2>Tasks (aka Coroutines)<a class="headerlink" href="#tasks-aka-coroutines" title="Permalink to this headline">¶</a></h2>
<p>Tasks are a control flow feature that allows computations to be
suspended and resumed in a flexible manner. This feature is sometimes
called by other names, such as symmetric coroutines, lightweight
threads, cooperative multitasking, or one-shot continuations.</p>
<p>When a piece of computing work (in practice, executing a particular
function) is designated as a <tt class="docutils literal"><span class="pre">Task</span></tt>, it becomes possible to interrupt
it by switching to another <tt class="docutils literal"><span class="pre">Task</span></tt>. The original <tt class="docutils literal"><span class="pre">Task</span></tt> can later be
resumed, at which point it will pick up right where it left off. At
first, this may seem similar to a function call. However there are two
key differences. First, switching tasks does not use any space, so any
number of task switches can occur without consuming the call stack.
Second, switching among tasks can occur in any order, unlike function calls,
where the called function must finish executing before control returns
to the calling function.</p>
<p>This kind of control flow can make it much easier to solve certain
problems. In some problems, the various pieces of required work are not
naturally related by function calls; there is no obvious “caller” or
“callee” among the jobs that need to be done. An example is the
producer-consumer problem, where one complex procedure is generating
values and another complex procedure is consuming them. The consumer
cannot simply call a producer function to get a value, because the
producer may have more values to generate and so might not yet be ready
to return. With tasks, the producer and consumer can both run as long as
they need to, passing values back and forth as necessary.</p>
<p>Julia provides the functions <tt class="docutils literal"><span class="pre">produce</span></tt> and <tt class="docutils literal"><span class="pre">consume</span></tt> for solving
this problem. A producer is a function that calls <tt class="docutils literal"><span class="pre">produce</span></tt> on each
value it needs to produce:</p>
<div class="highlight-julia"><div class="highlight"><pre><span class="n">julia</span><span class="o">></span> <span class="k">function</span><span class="nf"> producer</span><span class="p">()</span>
<span class="n">produce</span><span class="p">(</span><span class="s">"start"</span><span class="p">)</span>
<span class="k">for</span> <span class="n">n</span><span class="o">=</span><span class="mi">1</span><span class="p">:</span><span class="mi">4</span>
<span class="n">produce</span><span class="p">(</span><span class="mi">2</span><span class="n">n</span><span class="p">)</span>
<span class="k">end</span>
<span class="n">produce</span><span class="p">(</span><span class="s">"stop"</span><span class="p">)</span>
<span class="k">end</span><span class="p">;</span>
</pre></div>
</div>
<p>To consume values, first the producer is wrapped in a <tt class="docutils literal"><span class="pre">Task</span></tt>,
then <tt class="docutils literal"><span class="pre">consume</span></tt> is called repeatedly on that object:</p>
<div class="highlight-julia"><div class="highlight"><pre><span class="n">julia</span><span class="o">></span> <span class="n">p</span> <span class="o">=</span> <span class="n">Task</span><span class="p">(</span><span class="n">producer</span><span class="p">);</span>
<span class="n">julia</span><span class="o">></span> <span class="n">consume</span><span class="p">(</span><span class="n">p</span><span class="p">)</span>
<span class="s">"start"</span>
<span class="n">julia</span><span class="o">></span> <span class="n">consume</span><span class="p">(</span><span class="n">p</span><span class="p">)</span>
<span class="mi">2</span>
<span class="n">julia</span><span class="o">></span> <span class="n">consume</span><span class="p">(</span><span class="n">p</span><span class="p">)</span>
<span class="mi">4</span>
<span class="n">julia</span><span class="o">></span> <span class="n">consume</span><span class="p">(</span><span class="n">p</span><span class="p">)</span>
<span class="mi">6</span>
<span class="n">julia</span><span class="o">></span> <span class="n">consume</span><span class="p">(</span><span class="n">p</span><span class="p">)</span>
<span class="mi">8</span>
<span class="n">julia</span><span class="o">></span> <span class="n">consume</span><span class="p">(</span><span class="n">p</span><span class="p">)</span>
<span class="s">"stop"</span>
</pre></div>
</div>
<p>One way to think of this behavior is that <tt class="docutils literal"><span class="pre">producer</span></tt> was able to
return multiple times. Between calls to <tt class="docutils literal"><span class="pre">produce</span></tt>, the producer’s
execution is suspended and the consumer has control.</p>
<p>A Task can be used as an iterable object in a <tt class="docutils literal"><span class="pre">for</span></tt> loop, in which
case the loop variable takes on all the produced values:</p>
<div class="highlight-julia"><div class="highlight"><pre><span class="n">julia</span><span class="o">></span> <span class="k">for</span> <span class="n">x</span> <span class="k">in</span> <span class="n">Task</span><span class="p">(</span><span class="n">producer</span><span class="p">)</span>
<span class="n">println</span><span class="p">(</span><span class="n">x</span><span class="p">)</span>
<span class="k">end</span>
<span class="n">start</span>
<span class="mi">2</span>
<span class="mi">4</span>
<span class="mi">6</span>
<span class="mi">8</span>
<span class="n">stop</span>
</pre></div>
</div>
<p>Note that the <tt class="docutils literal"><span class="pre">Task()</span></tt> constructor expects a 0-argument function. A
common pattern is for the producer to be parameterized, in which case a
partial function application is needed to create a 0-argument <a class="reference internal" href="functions.html#man-anonymous-functions"><em>anonymous
function</em></a>. This can be done either
directly or by use of a convenience macro:</p>
<div class="highlight-julia"><div class="highlight"><pre><span class="k">function</span><span class="nf"> mytask</span><span class="p">(</span><span class="n">myarg</span><span class="p">)</span>
<span class="o">...</span>
<span class="k">end</span>
<span class="n">taskHdl</span> <span class="o">=</span> <span class="n">Task</span><span class="p">(()</span> <span class="o">-></span> <span class="n">mytask</span><span class="p">(</span><span class="mi">7</span><span class="p">))</span>
<span class="c"># or, equivalently</span>
<span class="n">taskHdl</span> <span class="o">=</span> <span class="p">@</span><span class="n">task</span> <span class="n">mytask</span><span class="p">(</span><span class="mi">7</span><span class="p">)</span>
</pre></div>
</div>
<p><tt class="docutils literal"><span class="pre">produce</span></tt> and <tt class="docutils literal"><span class="pre">consume</span></tt> do not launch threads that can run on separate CPUs.
True kernel threads are discussed under the topic of <a class="reference internal" href="parallel-computing.html#man-parallel-computing"><em>Parallel Computing</em></a>.</p>
<div class="section" id="core-task-operations">
<h3>Core task operations<a class="headerlink" href="#core-task-operations" title="Permalink to this headline">¶</a></h3>
<p>While <tt class="docutils literal"><span class="pre">produce</span></tt> and <tt class="docutils literal"><span class="pre">consume</span></tt> illustrate the essential nature of tasks, they
are actually implemented as library functions using a more primitive function,
<tt class="docutils literal"><span class="pre">yieldto</span></tt>. <tt class="docutils literal"><span class="pre">yieldto(task,value)</span></tt> suspends the current task, switches
to the specified <tt class="docutils literal"><span class="pre">task</span></tt>, and causes that task’s last <tt class="docutils literal"><span class="pre">yieldto</span></tt> call to return
the specified <tt class="docutils literal"><span class="pre">value</span></tt>. Notice that <tt class="docutils literal"><span class="pre">yieldto</span></tt> is the only operation required
to use task-style control flow; instead of calling and returning we are always
just switching to a different task. This is why this feature is also called
“symmetric coroutines”; each task is switched to and from using the same mechanism.</p>
<p><tt class="docutils literal"><span class="pre">yieldto</span></tt> is powerful, but most uses of tasks do not invoke it directly.
Consider why this might be. If you switch away from the current task, you will
probably want to switch back to it at some point, but knowing when to switch
back, and knowing which task has the responsibility of switching back, can
require considerable coordination. For example, <tt class="docutils literal"><span class="pre">produce</span></tt> needs to maintain
some state to remember who the consumer is. Not needing to manually keep track
of the consuming task is what makes <tt class="docutils literal"><span class="pre">produce</span></tt> easier to use than <tt class="docutils literal"><span class="pre">yieldto</span></tt>.</p>
<p>In addition to <tt class="docutils literal"><span class="pre">yieldto</span></tt>, a few other basic functions are needed to use tasks
effectively.
<tt class="docutils literal"><span class="pre">current_task()</span></tt> gets a reference to the currently-running task.
<tt class="docutils literal"><span class="pre">istaskdone(t)</span></tt> queries whether a task has exited.
<tt class="docutils literal"><span class="pre">istaskstarted(t)</span></tt> queries whether a task has run yet.
<tt class="docutils literal"><span class="pre">task_local_storage</span></tt> manipulates a key-value store specific to the current task.</p>
</div>
<div class="section" id="tasks-and-events">
<h3>Tasks and events<a class="headerlink" href="#tasks-and-events" title="Permalink to this headline">¶</a></h3>
<p>Most task switches occur as a result of waiting for events such as I/O
requests, and are performed by a scheduler included in the standard library.
The scheduler maintains a queue of runnable tasks, and executes an event loop
that restarts tasks based on external events such as message arrival.</p>
<p>The basic function for waiting for an event is <tt class="docutils literal"><span class="pre">wait</span></tt>. Several objects
implement <tt class="docutils literal"><span class="pre">wait</span></tt>; for example, given a <tt class="docutils literal"><span class="pre">Process</span></tt> object, <tt class="docutils literal"><span class="pre">wait</span></tt> will
wait for it to exit. <tt class="docutils literal"><span class="pre">wait</span></tt> is often implicit; for example, a <tt class="docutils literal"><span class="pre">wait</span></tt>
can happen inside a call to <tt class="docutils literal"><span class="pre">read</span></tt> to wait for data to be available.</p>
<p>In all of these cases, <tt class="docutils literal"><span class="pre">wait</span></tt> ultimately operates on a <tt class="docutils literal"><span class="pre">Condition</span></tt>
object, which is in charge of queueing and restarting tasks. When a task
calls <tt class="docutils literal"><span class="pre">wait</span></tt> on a <tt class="docutils literal"><span class="pre">Condition</span></tt>, the task is marked as non-runnable, added
to the condition’s queue, and switches to the scheduler. The scheduler will
then pick another task to run, or block waiting for external events.
If all goes well, eventually an event handler will call <tt class="docutils literal"><span class="pre">notify</span></tt> on the
condition, which causes tasks waiting for that condition to become runnable
again.</p>
<p>A task created explicitly by calling <tt class="docutils literal"><span class="pre">Task</span></tt> is initially not known to the
scheduler. This allows you to manage tasks manually using <tt class="docutils literal"><span class="pre">yieldto</span></tt> if
you wish. However, when such a task waits for an event, it still gets restarted
automatically when the event happens, as you would expect. It is also
possible to make the scheduler run a task whenever it can, without necessarily
waiting for any events. This is done by calling <tt class="docutils literal"><span class="pre">schedule(task)</span></tt>, or using
the <tt class="docutils literal"><span class="pre">@schedule</span></tt> or <tt class="docutils literal"><span class="pre">@async</span></tt> macros (see <a class="reference internal" href="parallel-computing.html#man-parallel-computing"><em>Parallel Computing</em></a> for
more details).</p>
</div>
<div class="section" id="task-states">
<h3>Task states<a class="headerlink" href="#task-states" title="Permalink to this headline">¶</a></h3>
<p>Tasks have a <tt class="docutils literal"><span class="pre">state</span></tt> field that describes their execution status. A task
state is one of the following symbols:</p>
<table border="1" class="docutils">
<colgroup>
<col width="21%" />
<col width="79%" />
</colgroup>
<thead valign="bottom">
<tr class="row-odd"><th class="head">Symbol</th>
<th class="head">Meaning</th>
</tr>
</thead>
<tbody valign="top">
<tr class="row-even"><td><tt class="docutils literal"><span class="pre">:runnable</span></tt></td>
<td>Currently running, or available to be switched to</td>
</tr>
<tr class="row-odd"><td><tt class="docutils literal"><span class="pre">:waiting</span></tt></td>
<td>Blocked waiting for a specific event</td>
</tr>
<tr class="row-even"><td><tt class="docutils literal"><span class="pre">:queued</span></tt></td>
<td>In the scheduler’s run queue about to be restarted</td>
</tr>
<tr class="row-odd"><td><tt class="docutils literal"><span class="pre">:done</span></tt></td>
<td>Successfully finished executing</td>
</tr>
<tr class="row-even"><td><tt class="docutils literal"><span class="pre">:failed</span></tt></td>
<td>Finished with an uncaught exception</td>
</tr>
</tbody>
</table>
</div>
</div>
</div>
</div>
<footer>
<div class="rst-footer-buttons" role="navigation" aria-label="footer navigation">
<a href="variables-and-scoping.html" class="btn btn-neutral float-right" title="Scope of Variables"/>Next <span class="fa fa-arrow-circle-right"></span></a>
<a href="functions.html" class="btn btn-neutral" title="Functions"><span class="fa fa-arrow-circle-left"></span> Previous</a>
</div>
<hr/>
<div role="contentinfo">
<p>
</p>
</div>
<a href="https://github.com/snide/sphinx_rtd_theme">Sphinx theme</a> provided by <a href="https://readthedocs.org">Read the Docs</a>
</footer>
</div>
</div>
</section>
</div>
<script type="text/javascript">
var DOCUMENTATION_OPTIONS = {
URL_ROOT:'../',
VERSION:'0.3.4',
COLLAPSE_INDEX:false,
FILE_SUFFIX:'.html',
HAS_SOURCE: true
};
</script>
<script type="text/javascript" src="../_static/jquery.js"></script>
<script type="text/javascript" src="../_static/underscore.js"></script>
<script type="text/javascript" src="../_static/doctools.js"></script>
<script type="text/javascript" src="http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>
<script type="text/javascript" src="../_static/js/theme.js"></script>
<script type="text/javascript">
jQuery(function () {
SphinxRtdTheme.StickyNav.enable();
});
</script>
</body>
</html>
