<!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>Frequently Asked Questions — 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="Noteworthy Differences from other Languages" href="noteworthy-differences.html"/>
<link rel="prev" title="Style Guide" href="style-guide.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"><a class="reference internal" href="control-flow.html">Control Flow</a><ul>
<li class="toctree-l2"><a class="reference internal" href="control-flow.html#compound-expressions">Compound Expressions</a></li>
<li class="toctree-l2"><a class="reference internal" href="control-flow.html#conditional-evaluation">Conditional Evaluation</a></li>
<li class="toctree-l2"><a class="reference internal" href="control-flow.html#short-circuit-evaluation">Short-Circuit Evaluation</a></li>
<li class="toctree-l2"><a class="reference internal" href="control-flow.html#repeated-evaluation-loops">Repeated Evaluation: Loops</a></li>
<li class="toctree-l2"><a class="reference internal" href="control-flow.html#exception-handling">Exception Handling</a></li>
<li class="toctree-l2"><a class="reference internal" href="control-flow.html#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 current"><a class="current reference internal" href="">Frequently Asked Questions</a><ul>
<li class="toctree-l2"><a class="reference internal" href="#sessions-and-the-repl">Sessions and the REPL</a></li>
<li class="toctree-l2"><a class="reference internal" href="#functions">Functions</a></li>
<li class="toctree-l2"><a class="reference internal" href="#types-type-declarations-and-constructors">Types, type declarations, and constructors</a></li>
<li class="toctree-l2"><a class="reference internal" href="#nothingness-and-missing-values">Nothingness and missing values</a></li>
<li class="toctree-l2"><a class="reference internal" href="#julia-releases">Julia Releases</a></li>
<li class="toctree-l2"><a class="reference internal" href="#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>Frequently Asked Questions</li>
<li class="wy-breadcrumbs-aside">
<a href="../_sources/manual/faq.txt" rel="nofollow"> View page source</a>
</li>
</ul>
<hr/>
</div>
<div role="main" class="document">
<div class="section" id="frequently-asked-questions">
<span id="man-faq"></span><h1>Frequently Asked Questions<a class="headerlink" href="#frequently-asked-questions" title="Permalink to this headline">¶</a></h1>
<div class="section" id="sessions-and-the-repl">
<h2>Sessions and the REPL<a class="headerlink" href="#sessions-and-the-repl" title="Permalink to this headline">¶</a></h2>
<div class="section" id="how-do-i-delete-an-object-in-memory">
<h3>How do I delete an object in memory?<a class="headerlink" href="#how-do-i-delete-an-object-in-memory" title="Permalink to this headline">¶</a></h3>
<p>Julia does not have an analog of MATLAB’s <tt class="docutils literal"><span class="pre">clear</span></tt> function; once a
name is defined in a Julia session (technically, in module <tt class="docutils literal"><span class="pre">Main</span></tt>),
it is always present.</p>
<p>If memory usage is your concern, you can always replace objects with
ones that consume less memory. For example, if <tt class="docutils literal"><span class="pre">A</span></tt> is a
gigabyte-sized array that you no longer need, you can free the memory
with <tt class="docutils literal"><span class="pre">A</span> <span class="pre">=</span> <span class="pre">0</span></tt>. The memory will be released the next time the garbage
collector runs; you can force this to happen with <tt class="docutils literal"><span class="pre">gc()</span></tt>.</p>
</div>
<div class="section" id="how-can-i-modify-the-declaration-of-a-type-immutable-in-my-session">
<h3>How can I modify the declaration of a type/immutable in my session?<a class="headerlink" href="#how-can-i-modify-the-declaration-of-a-type-immutable-in-my-session" title="Permalink to this headline">¶</a></h3>
<p>Perhaps you’ve defined a type and then realize you need to add a
new field. If you try this at the REPL, you get the error:</p>
<div class="highlight-julia"><div class="highlight"><pre><span class="n">ERROR</span><span class="p">:</span> <span class="n">invalid</span> <span class="n">redefinition</span> <span class="n">of</span> <span class="n">constant</span> <span class="n">MyType</span>
</pre></div>
</div>
<p>Types in module <tt class="docutils literal"><span class="pre">Main</span></tt> cannot be redefined.</p>
<p>While this can be inconvenient when you are developing new code,
there’s an excellent workaround. Modules can be replaced by
redefining them, and so if you wrap all your new code inside a module
you can redefine types and constants. You can’t import the type names
into <tt class="docutils literal"><span class="pre">Main</span></tt> and then expect to be able to redefine them there, but
you can use the module name to resolve the scope. In other words,
while developing you might use a workflow something like this:</p>
<div class="highlight-julia"><div class="highlight"><pre><span class="n">include</span><span class="p">(</span><span class="s">"mynewcode.jl"</span><span class="p">)</span> <span class="c"># this defines a module MyModule</span>
<span class="n">obj1</span> <span class="o">=</span> <span class="n">MyModule</span><span class="o">.</span><span class="n">ObjConstructor</span><span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="n">b</span><span class="p">)</span>
<span class="n">obj2</span> <span class="o">=</span> <span class="n">MyModule</span><span class="o">.</span><span class="n">somefunction</span><span class="p">(</span><span class="n">obj1</span><span class="p">)</span>
<span class="c"># Got an error. Change something in "mynewcode.jl"</span>
<span class="n">include</span><span class="p">(</span><span class="s">"mynewcode.jl"</span><span class="p">)</span> <span class="c"># reload the module</span>
<span class="n">obj1</span> <span class="o">=</span> <span class="n">MyModule</span><span class="o">.</span><span class="n">ObjConstructor</span><span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="n">b</span><span class="p">)</span> <span class="c"># old objects are no longer valid, must reconstruct</span>
<span class="n">obj2</span> <span class="o">=</span> <span class="n">MyModule</span><span class="o">.</span><span class="n">somefunction</span><span class="p">(</span><span class="n">obj1</span><span class="p">)</span> <span class="c"># this time it worked!</span>
<span class="n">obj3</span> <span class="o">=</span> <span class="n">MyModule</span><span class="o">.</span><span class="n">someotherfunction</span><span class="p">(</span><span class="n">obj2</span><span class="p">,</span> <span class="n">c</span><span class="p">)</span>
<span class="o">...</span>
</pre></div>
</div>
</div>
</div>
<div class="section" id="functions">
<h2>Functions<a class="headerlink" href="#functions" title="Permalink to this headline">¶</a></h2>
<div class="section" id="i-passed-an-argument-x-to-a-function-modified-it-inside-that-function-but-on-the-outside-the-variable-x-is-still-unchanged-why">
<h3>I passed an argument <tt class="docutils literal"><span class="pre">x</span></tt> to a function, modified it inside that function, but on the outside, the variable <tt class="docutils literal"><span class="pre">x</span></tt> is still unchanged. Why?<a class="headerlink" href="#i-passed-an-argument-x-to-a-function-modified-it-inside-that-function-but-on-the-outside-the-variable-x-is-still-unchanged-why" title="Permalink to this headline">¶</a></h3>
<p>Suppose you call a function like this:</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">10</span>
<span class="n">julia</span><span class="o">></span> <span class="k">function</span><span class="nf"> change_value</span><span class="o">!</span><span class="p">(</span><span class="n">y</span><span class="p">)</span> <span class="c"># Create a new function</span>
<span class="n">y</span> <span class="o">=</span> <span class="mi">17</span>
<span class="k">end</span>
<span class="n">julia</span><span class="o">></span> <span class="n">change_value</span><span class="o">!</span><span class="p">(</span><span class="n">x</span><span class="p">)</span>
<span class="n">julia</span><span class="o">></span> <span class="n">x</span> <span class="c"># x is unchanged!</span>
<span class="mi">10</span>
</pre></div>
</div>
<p>In Julia, any function (including <tt class="docutils literal"><span class="pre">change_value!()</span></tt>) can’t change the binding of a local variable. If <tt class="docutils literal"><span class="pre">x</span></tt> (in the calling scope) is bound to a immutable object (like a real number), you can’t modify the object; likewise, if x is bound in the calling scope to a Dict, you can’t change it to be bound to an ASCIIString.</p>
<p>But here is a thing you should pay attention to: suppose <tt class="docutils literal"><span class="pre">x</span></tt> is bound to an Array (or any other mutable type). You cannot “unbind” <tt class="docutils literal"><span class="pre">x</span></tt> from this Array. But, since an Array is a <em>mutable</em> type, you can change its content. For example:</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="p">[</span><span class="mi">1</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="mi">3</span><span class="o">-</span><span class="n">element</span> <span class="n">Array</span><span class="p">{</span><span class="kt">Int64</span><span class="p">,</span><span class="mi">1</span><span class="p">}:</span>
<span class="mi">1</span>
<span class="mi">2</span>
<span class="mi">3</span>
<span class="n">julia</span><span class="o">></span> <span class="k">function</span><span class="nf"> change_array</span><span class="o">!</span><span class="p">(</span><span class="n">A</span><span class="p">)</span> <span class="c"># Create a new function</span>
<span class="n">A</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span> <span class="o">=</span> <span class="mi">5</span>
<span class="k">end</span>
<span class="n">julia</span><span class="o">></span> <span class="n">change_array</span><span class="o">!</span><span class="p">(</span><span class="n">x</span><span class="p">)</span>
<span class="n">julia</span><span class="o">></span> <span class="n">x</span>
<span class="mi">3</span><span class="o">-</span><span class="n">element</span> <span class="n">Array</span><span class="p">{</span><span class="kt">Int64</span><span class="p">,</span><span class="mi">1</span><span class="p">}:</span>
<span class="mi">5</span>
<span class="mi">2</span>
<span class="mi">3</span>
</pre></div>
</div>
<p>Here we created a function <tt class="docutils literal"><span class="pre">change_array!()</span></tt>, that assigns <tt class="docutils literal"><span class="pre">5</span></tt> to the first element of the Array. We passed <tt class="docutils literal"><span class="pre">x</span></tt> (which was previously bound to an Array) to the function. Notice that, after the function call, <tt class="docutils literal"><span class="pre">x</span></tt> is still bound to the same Array, but the content of that Array changed.</p>
</div>
<div class="section" id="can-i-use-using-or-import-inside-a-function">
<h3>Can I use <tt class="docutils literal"><span class="pre">using</span></tt> or <tt class="docutils literal"><span class="pre">import</span></tt> inside a function?<a class="headerlink" href="#can-i-use-using-or-import-inside-a-function" title="Permalink to this headline">¶</a></h3>
<p>No, you are not allowed to have a <tt class="docutils literal"><span class="pre">using</span></tt> or <tt class="docutils literal"><span class="pre">import</span></tt> statement inside
a function. If you want to import a module but only use its symbols
inside a specific function or set of functions, you have two options:</p>
<ol class="arabic">
<li><p class="first">Use <tt class="docutils literal"><span class="pre">import</span></tt>:</p>
<div class="highlight-julia"><div class="highlight"><pre><span class="k">import</span> <span class="n">Foo</span>
<span class="k">function</span><span class="nf"> bar</span><span class="p">(</span><span class="o">...</span><span class="p">)</span>
<span class="o">...</span> <span class="n">refer</span> <span class="n">to</span> <span class="n">Foo</span> <span class="n">symbols</span> <span class="n">via</span> <span class="n">Foo</span><span class="o">.</span><span class="n">baz</span> <span class="o">...</span>
<span class="k">end</span>
</pre></div>
</div>
<p>This loads the module Foo and defines a variable <tt class="docutils literal"><span class="pre">Foo</span></tt> that refers
to the module, but does not import any of the other symbols from the
module into the current namespace. You refer to the <tt class="docutils literal"><span class="pre">Foo</span></tt> symbols by
their qualified names <tt class="docutils literal"><span class="pre">Foo.bar</span></tt> etc.</p>
</li>
<li><p class="first">Wrap your function in a module:</p>
<div class="highlight-julia"><div class="highlight"><pre><span class="k">module</span> <span class="n">Bar</span>
<span class="k">export</span> <span class="n">bar</span>
<span class="k">using</span> <span class="n">Foo</span>
<span class="k">function</span><span class="nf"> bar</span><span class="p">(</span><span class="o">...</span><span class="p">)</span>
<span class="o">...</span> <span class="n">refer</span> <span class="n">to</span> <span class="n">Foo</span><span class="o">.</span><span class="n">baz</span> <span class="n">as</span> <span class="n">simply</span> <span class="n">baz</span> <span class="o">....</span>
<span class="k">end</span>
<span class="k">end</span>
<span class="k">using</span> <span class="n">Bar</span>
</pre></div>
</div>
<p>This imports all the symbols from Foo, but only inside the module Bar.</p>
</li>
</ol>
</div>
<div class="section" id="what-does-the-operator-do">
<span id="man-slurping-splatting"></span><h3>What does the <tt class="docutils literal"><span class="pre">...</span></tt> operator do?<a class="headerlink" href="#what-does-the-operator-do" title="Permalink to this headline">¶</a></h3>
</div>
<div class="section" id="the-two-uses-of-the-operator-slurping-and-splatting">
<h3>The two uses of the <cite>...</cite> operator: slurping and splatting<a class="headerlink" href="#the-two-uses-of-the-operator-slurping-and-splatting" title="Permalink to this headline">¶</a></h3>
<p>Many newcomers to Julia find the use of <tt class="docutils literal"><span class="pre">...</span></tt> operator confusing. Part of
what makes the <tt class="docutils literal"><span class="pre">...</span></tt> operator confusing is that it means two different things
depending on context.</p>
</div>
<div class="section" id="combines-many-arguments-into-one-argument-in-function-definitions">
<h3><tt class="docutils literal"><span class="pre">...</span></tt> combines many arguments into one argument in function definitions<a class="headerlink" href="#combines-many-arguments-into-one-argument-in-function-definitions" title="Permalink to this headline">¶</a></h3>
<p>In the context of function definitions, the <tt class="docutils literal"><span class="pre">...</span></tt> operator is used to combine
many different arguments into a single argument. This use of <tt class="docutils literal"><span class="pre">...</span></tt> for
combining many different arguments into a single argument is called slurping:</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"> printargs</span><span class="p">(</span><span class="n">args</span><span class="o">...</span><span class="p">)</span>
<span class="p">@</span><span class="n">printf</span><span class="p">(</span><span class="s">"%s</span><span class="se">\n</span><span class="s">"</span><span class="p">,</span> <span class="nb">typeof</span><span class="p">(</span><span class="n">args</span><span class="p">))</span>
<span class="k">for</span> <span class="p">(</span><span class="n">i</span><span class="p">,</span> <span class="n">arg</span><span class="p">)</span> <span class="k">in</span> <span class="n">enumerate</span><span class="p">(</span><span class="n">args</span><span class="p">)</span>
<span class="p">@</span><span class="n">printf</span><span class="p">(</span><span class="s">"Arg %d = %s</span><span class="se">\n</span><span class="s">"</span><span class="p">,</span> <span class="n">i</span><span class="p">,</span> <span class="n">arg</span><span class="p">)</span>
<span class="k">end</span>
<span class="k">end</span>
<span class="n">printargs</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">printargs</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="mi">3</span><span class="p">)</span>
<span class="p">(</span><span class="kt">Int64</span><span class="p">,</span><span class="kt">Int64</span><span class="p">,</span><span class="kt">Int64</span><span class="p">)</span>
<span class="n">Arg</span> <span class="mi">1</span> <span class="o">=</span> <span class="mi">1</span>
<span class="n">Arg</span> <span class="mi">2</span> <span class="o">=</span> <span class="mi">2</span>
<span class="n">Arg</span> <span class="mi">3</span> <span class="o">=</span> <span class="mi">3</span>
</pre></div>
</div>
<p>If Julia were a language that made more liberal use of ASCII characters, the
slurping operator might have been written as <tt class="docutils literal"><span class="pre"><-...</span></tt> instead of <tt class="docutils literal"><span class="pre">...</span></tt>.</p>
</div>
<div class="section" id="splits-one-argument-into-many-different-arguments-in-function-calls">
<h3><tt class="docutils literal"><span class="pre">...</span></tt> splits one argument into many different arguments in function calls<a class="headerlink" href="#splits-one-argument-into-many-different-arguments-in-function-calls" title="Permalink to this headline">¶</a></h3>
<p>In contrast to the use of the <tt class="docutils literal"><span class="pre">...</span></tt> operator to denote slurping many
different arguments into one argument when defining a function, the <tt class="docutils literal"><span class="pre">...</span></tt>
operator is also used to cause a single function argument to be split apart
into many different arguments when used in the context of a function call. This
use of <tt class="docutils literal"><span class="pre">...</span></tt> is called splatting:</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"> threeargs</span><span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="n">b</span><span class="p">,</span> <span class="n">c</span><span class="p">)</span>
<span class="p">@</span><span class="n">printf</span><span class="p">(</span><span class="s">"a = %s::%s</span><span class="se">\n</span><span class="s">"</span><span class="p">,</span> <span class="n">a</span><span class="p">,</span> <span class="nb">typeof</span><span class="p">(</span><span class="n">a</span><span class="p">))</span>
<span class="p">@</span><span class="n">printf</span><span class="p">(</span><span class="s">"b = %s::%s</span><span class="se">\n</span><span class="s">"</span><span class="p">,</span> <span class="n">b</span><span class="p">,</span> <span class="nb">typeof</span><span class="p">(</span><span class="n">b</span><span class="p">))</span>
<span class="p">@</span><span class="n">printf</span><span class="p">(</span><span class="s">"c = %s::%s</span><span class="se">\n</span><span class="s">"</span><span class="p">,</span> <span class="n">c</span><span class="p">,</span> <span class="nb">typeof</span><span class="p">(</span><span class="n">c</span><span class="p">))</span>
<span class="k">end</span>
<span class="n">threeargs</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">vec</span> <span class="o">=</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="mi">3</span><span class="p">]</span>
<span class="mi">3</span><span class="o">-</span><span class="n">element</span> <span class="n">Array</span><span class="p">{</span><span class="kt">Int64</span><span class="p">,</span><span class="mi">1</span><span class="p">}:</span>
<span class="mi">1</span>
<span class="mi">2</span>
<span class="mi">3</span>
<span class="n">julia</span><span class="o">></span> <span class="n">threeargs</span><span class="p">(</span><span class="n">vec</span><span class="o">...</span><span class="p">)</span>
<span class="n">a</span> <span class="o">=</span> <span class="mi">1</span><span class="p">::</span><span class="kt">Int64</span>
<span class="n">b</span> <span class="o">=</span> <span class="mi">2</span><span class="p">::</span><span class="kt">Int64</span>
<span class="n">c</span> <span class="o">=</span> <span class="mi">3</span><span class="p">::</span><span class="kt">Int64</span>
</pre></div>
</div>
<p>If Julia were a language that made more liberal use of ASCII characters,
the splatting operator might have been written as <tt class="docutils literal"><span class="pre">...-></span></tt> instead of <tt class="docutils literal"><span class="pre">...</span></tt>.</p>
</div>
</div>
<div class="section" id="types-type-declarations-and-constructors">
<h2>Types, type declarations, and constructors<a class="headerlink" href="#types-type-declarations-and-constructors" title="Permalink to this headline">¶</a></h2>
<div class="section" id="what-does-type-stable-mean">
<span id="man-type-stable"></span><h3>What does “type-stable” mean?<a class="headerlink" href="#what-does-type-stable-mean" title="Permalink to this headline">¶</a></h3>
<p>It means that the type of the output is predictable from the types
of the inputs. In particular, it means that the type of the output
cannot vary depending on the <em>values</em> of the inputs. The following
code is <em>not</em> type-stable:</p>
<div class="highlight-julia"><div class="highlight"><pre><span class="k">function</span><span class="nf"> unstable</span><span class="p">(</span><span class="n">flag</span><span class="p">::</span><span class="kt">Bool</span><span class="p">)</span>
<span class="k">if</span> <span class="n">flag</span>
<span class="k">return</span> <span class="mi">1</span>
<span class="k">else</span>
<span class="k">return</span> <span class="mf">1.0</span>
<span class="k">end</span>
<span class="k">end</span>
</pre></div>
</div>
<p>It returns either an <tt class="docutils literal"><span class="pre">Int</span></tt> or a <tt class="docutils literal"><span class="pre">Float64</span></tt> depending on the value of its
argument. Since Julia can’t predict the return type of this function at
compile-time, any computation that uses it will have to guard against both
types possibly occurring, making generation of fast machine code difficult.</p>
</div>
<div class="section" id="why-does-julia-give-a-domainerror-for-certain-seemingly-sensible-operations">
<span id="man-domain-error"></span><h3>Why does Julia give a <tt class="docutils literal"><span class="pre">DomainError</span></tt> for certain seemingly-sensible operations?<a class="headerlink" href="#why-does-julia-give-a-domainerror-for-certain-seemingly-sensible-operations" title="Permalink to this headline">¶</a></h3>
<p>Certain operations make mathematical sense but result in errors:</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="mf">2.0</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</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">128</span>
<span class="n">julia</span><span class="o">></span> <span class="mi">2</span><span class="o">^-</span><span class="mi">5</span>
<span class="n">ERROR</span><span class="p">:</span> <span class="n">DomainError</span>
<span class="k">in</span> <span class="n">power_by_squaring</span> <span class="n">at</span> <span class="n">intfuncs</span><span class="o">.</span><span class="n">jl</span><span class="p">:</span><span class="mi">70</span>
<span class="k">in</span> <span class="o">^</span> <span class="n">at</span> <span class="n">intfuncs</span><span class="o">.</span><span class="n">jl</span><span class="p">:</span><span class="mi">84</span>
</pre></div>
</div>
<p>This behavior is an inconvenient consequence of the requirement for
type-stability. In the case of <tt class="docutils literal"><span class="pre">sqrt</span></tt>, most users want
<tt class="docutils literal"><span class="pre">sqrt(2.0)</span></tt> to give a real number, and would be unhappy if it
produced the complex number <tt class="docutils literal"><span class="pre">1.4142135623730951</span> <span class="pre">+</span> <span class="pre">0.0im</span></tt>. One could
write the <tt class="docutils literal"><span class="pre">sqrt</span></tt> function to switch to a complex-valued output only
when passed a negative number (which is what <tt class="docutils literal"><span class="pre">sqrt</span></tt> does in some
other languages), but then the result would not be <a class="reference external" href="#man-type-stable">type-stable</a> and the <tt class="docutils literal"><span class="pre">sqrt</span></tt> function would have poor
performance.</p>
<p>In these and other cases, you can get the result you want by choosing
an <em>input type</em> that conveys your willingness to accept an <em>output type</em> in
which the result can be represented:</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="mf">2.0</span><span class="o">+</span><span class="mi">0</span><span class="nb">im</span><span class="p">)</span>
<span class="mf">0.0</span> <span class="o">+</span> <span class="mf">1.4142135623730951</span><span class="nb">im</span>
<span class="n">julia</span><span class="o">></span> <span class="mf">2.0</span><span class="o">^-</span><span class="mi">5</span>
<span class="mf">0.03125</span>
</pre></div>
</div>
</div>
<div class="section" id="why-does-julia-use-native-machine-integer-arithmetic">
<h3>Why does Julia use native machine integer arithmetic?<a class="headerlink" href="#why-does-julia-use-native-machine-integer-arithmetic" title="Permalink to this headline">¶</a></h3>
<p>Julia uses machine arithmetic for integer computations. This means that the range of <tt class="docutils literal"><span class="pre">Int</span></tt> values is bounded and wraps around at either end so that adding, subtracting and multiplying integers can overflow or underflow, leading to some results that can be unsettling at first:</p>
<div class="highlight-julia"><div class="highlight"><pre><span class="n">julia</span><span class="o">></span> <span class="nb">typemax</span><span class="p">(</span><span class="kt">Int</span><span class="p">)</span>
<span class="mi">9223372036854775807</span>
<span class="n">julia</span><span class="o">></span> <span class="n">ans</span><span class="o">+</span><span class="mi">1</span>
<span class="o">-</span><span class="mi">9223372036854775808</span>
<span class="n">julia</span><span class="o">></span> <span class="o">-</span><span class="n">ans</span>
<span class="o">-</span><span class="mi">9223372036854775808</span>
<span class="n">julia</span><span class="o">></span> <span class="mi">2</span><span class="o">*</span><span class="n">ans</span>
<span class="mi">0</span>
</pre></div>
</div>
<p>Clearly, this is far from the way mathematical integers behave, and you might
think it less than ideal for a high-level programming language to expose this
to the user. For numerical work where efficiency and transparency are at a
premium, however, the alternatives are worse.</p>
<p>One alternative to consider would be to check each integer operation for
overflow and promote results to bigger integer types such as <tt class="docutils literal"><span class="pre">Int128</span></tt> or
<tt class="docutils literal"><span class="pre">BigInt</span></tt> in the case of overflow. Unfortunately, this introduces major
overhead on every integer operation (think incrementing a loop counter) – it
requires emitting code to perform run-time overflow checks after arithmetic
instructions and braches to handle potential overflows. Worse still, this
would cause every computation involving integers to be type-unstable. As we
mentioned above, <a class="reference external" href="#man-type-stable">type-stability is crucial</a> for effective
generation of efficient code. If you can’t count on the results of integer
operations being integers, it’s impossible to generate fast, simple code the
way C and Fortran compilers do.</p>
<p>A variation on this approach, which avoids the appearance of type instabilty is to merge the <tt class="docutils literal"><span class="pre">Int</span></tt> and <tt class="docutils literal"><span class="pre">BigInt</span></tt> types into a single hybrid integer type, that internally changes representation when a result no longer fits into the size of a machine integer. While this superficially avoids type-instability at the level of Julia code, it just sweeps the problem under the rug by foisting all of the same difficulties onto the C code implementing this hybrid integer type. This approach <em>can</em> be made to work and can even be made quite fast in many cases, but has several drawbacks. One problem is that the in-memory representation of integers and arrays of integers no longer match the natural representation used by C, Fortran and other languages with native machine integers. Thus, to interoperate with those languages, we would ultimately need to introduce native integer types anyway. Any unbounded representation of integers cannot have a fixed number of bits, and thus cannot be stored inline in an array with fixed-size slots – large integer values will always require separate heap-allocated storage. And of course, no matter how clever a hybrid integer implementation one uses, there are always performance traps – situations where performance degrades unexpectedly. Complex representation, lack of interoperability with C and Fortran, the inability to represent integer arrays without additional heap storage, and unpredictable performance characteristics make even the cleverest hybrid integer implementations a poor choice for high-performance numerical work.</p>
<p>An alternative to using hybrid integers or promoting to BigInts is to use
saturating integer arithmetic, where adding to the largest integer value
leaves it unchanged and likewise for subtracting from the smallest integer
value. This is precisely what Matlab™ does:</p>
<div class="highlight-julia"><div class="highlight"><pre><span class="o">>></span> <span class="n">int64</span><span class="p">(</span><span class="mi">9223372036854775807</span><span class="p">)</span>
<span class="n">ans</span> <span class="o">=</span>
<span class="mi">9223372036854775807</span>
<span class="o">>></span> <span class="n">int64</span><span class="p">(</span><span class="mi">9223372036854775807</span><span class="p">)</span> <span class="o">+</span> <span class="mi">1</span>
<span class="n">ans</span> <span class="o">=</span>
<span class="mi">9223372036854775807</span>
<span class="o">>></span> <span class="n">int64</span><span class="p">(</span><span class="o">-</span><span class="mi">9223372036854775808</span><span class="p">)</span>
<span class="n">ans</span> <span class="o">=</span>
<span class="o">-</span><span class="mi">9223372036854775808</span>
<span class="o">>></span> <span class="n">int64</span><span class="p">(</span><span class="o">-</span><span class="mi">9223372036854775808</span><span class="p">)</span> <span class="o">-</span> <span class="mi">1</span>
<span class="n">ans</span> <span class="o">=</span>
<span class="o">-</span><span class="mi">9223372036854775808</span>
</pre></div>
</div>
<p>At first blush, this seems reasonable enough since 9223372036854775807 is much closer to 9223372036854775808 than -9223372036854775808 is and integers are still represented with a fixed size in a natural way that is compatible with C and Fortran. Saturated integer arithmetic, however, is deeply problematic. The first and most obvious issue is that this is not the way machine integer arithmetic works, so implementing saturated operations requires emiting instructions after each machine integer operation to check for underflow or overflow and replace the result with <tt class="docutils literal"><span class="pre">typemin(Int)</span></tt> or <tt class="docutils literal"><span class="pre">typemax(Int)</span></tt> as appropriate. This alone expands each integer operation from a single, fast instruction into half a dozen instructions, probably including branches. Ouch. But it gets worse – saturating integer arithmetic isn’t associative. Consider this Matlab computation:</p>
<div class="highlight-julia"><div class="highlight"><pre><span class="o">>></span> <span class="n">n</span> <span class="o">=</span> <span class="n">int64</span><span class="p">(</span><span class="mi">2</span><span class="p">)</span><span class="o">^</span><span class="mi">62</span>
<span class="mi">4611686018427387904</span>
<span class="o">>></span> <span class="n">n</span> <span class="o">+</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="mi">9223372036854775807</span>
<span class="o">>></span> <span class="p">(</span><span class="n">n</span> <span class="o">+</span> <span class="n">n</span><span class="p">)</span> <span class="o">-</span> <span class="mi">1</span>
<span class="mi">9223372036854775806</span>
</pre></div>
</div>
<p>This makes it hard to write many basic integer algorithms since a lot of
common techniques depend on the fact that machine addition with overflow <em>is</em>
associative. Consider finding the midpoint between integer values <tt class="docutils literal"><span class="pre">lo</span></tt> and
<tt class="docutils literal"><span class="pre">hi</span></tt> in Julia using the expression <tt class="docutils literal"><span class="pre">(lo</span> <span class="pre">+</span> <span class="pre">hi)</span> <span class="pre">>>></span> <span class="pre">1</span></tt>:</p>
<div class="highlight-julia"><div class="highlight"><pre><span class="n">julia</span><span class="o">></span> <span class="n">n</span> <span class="o">=</span> <span class="mi">2</span><span class="o">^</span><span class="mi">62</span>
<span class="mi">4611686018427387904</span>
<span class="n">julia</span><span class="o">></span> <span class="p">(</span><span class="n">n</span> <span class="o">+</span> <span class="mi">2</span><span class="n">n</span><span class="p">)</span> <span class="o">>>></span> <span class="mi">1</span>
<span class="mi">6917529027641081856</span>
</pre></div>
</div>
<p>See? No problem. That’s the correct midpoint between 2^62 and 2^63, despite
the fact that <tt class="docutils literal"><span class="pre">n</span> <span class="pre">+</span> <span class="pre">2n</span></tt> is -4611686018427387904. Now try it in Matlab:</p>
<div class="highlight-julia"><div class="highlight"><pre><span class="o">>></span> <span class="p">(</span><span class="n">n</span> <span class="o">+</span> <span class="mi">2</span><span class="o">*</span><span class="n">n</span><span class="p">)</span><span class="o">/</span><span class="mi">2</span>
<span class="n">ans</span> <span class="o">=</span>
<span class="mi">4611686018427387904</span>
</pre></div>
</div>
<p>Oops. Adding a <tt class="docutils literal"><span class="pre">>>></span></tt> operator to Matlab wouldn’t help, because saturation
that occurs when adding <tt class="docutils literal"><span class="pre">n</span></tt> and <tt class="docutils literal"><span class="pre">2n</span></tt> has already destroyed the information
necessary to compute the correct midpoint.</p>
<p>Not only is lack of associativity unfortunate for programmers who cannot rely
it for techniques like this, but it also defeats almost anything compilers
might want to do to optimize integer arithmetic. For example, since Julia
integers use normal machine integer arithmetic, LLVM is free to aggressively
optimize simple little functions like <tt class="docutils literal"><span class="pre">f(k)</span> <span class="pre">=</span> <span class="pre">5k-1</span></tt>. The machine code for
this function is just this:</p>
<div class="highlight-julia"><div class="highlight"><pre><span class="n">julia</span><span class="o">></span> <span class="n">code_native</span><span class="p">(</span><span class="n">f</span><span class="p">,(</span><span class="kt">Int</span><span class="p">,))</span>
<span class="o">.</span><span class="n">section</span> <span class="n">__TEXT</span><span class="p">,</span><span class="n">__text</span><span class="p">,</span><span class="n">regular</span><span class="p">,</span><span class="n">pure_instructions</span>
<span class="n">Filename</span><span class="p">:</span> <span class="n">none</span>
<span class="n">Source</span> <span class="n">line</span><span class="p">:</span> <span class="mi">1</span>
<span class="n">push</span> <span class="n">RBP</span>
<span class="n">mov</span> <span class="n">RBP</span><span class="p">,</span> <span class="n">RSP</span>
<span class="n">Source</span> <span class="n">line</span><span class="p">:</span> <span class="mi">1</span>
<span class="n">lea</span> <span class="n">RAX</span><span class="p">,</span> <span class="n">QWORD</span> <span class="n">PTR</span> <span class="p">[</span><span class="n">RDI</span> <span class="o">+</span> <span class="mi">4</span><span class="o">*</span><span class="n">RDI</span> <span class="o">-</span> <span class="mi">1</span><span class="p">]</span>
<span class="n">pop</span> <span class="n">RBP</span>
<span class="n">ret</span>
</pre></div>
</div>
<p>The actual body of the function is a single <tt class="docutils literal"><span class="pre">lea</span></tt> instruction, which
computes the integer multiply and add at once. This is even more beneficial
when <tt class="docutils literal"><span class="pre">f</span></tt> gets inlined into another function:</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"> g</span><span class="p">(</span><span class="n">k</span><span class="p">,</span><span class="n">n</span><span class="p">)</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="n">n</span>
<span class="n">k</span> <span class="o">=</span> <span class="n">f</span><span class="p">(</span><span class="n">k</span><span class="p">)</span>
<span class="k">end</span>
<span class="k">return</span> <span class="n">k</span>
<span class="k">end</span>
<span class="n">g</span> <span class="p">(</span><span class="n">generic</span> <span class="k">function</span><span class="nf"> with</span> <span class="mi">2</span> <span class="n">methods</span><span class="p">)</span>
<span class="n">julia</span><span class="o">></span> <span class="n">code_native</span><span class="p">(</span><span class="n">g</span><span class="p">,(</span><span class="kt">Int</span><span class="p">,</span><span class="kt">Int</span><span class="p">))</span>
<span class="o">.</span><span class="n">section</span> <span class="n">__TEXT</span><span class="p">,</span><span class="n">__text</span><span class="p">,</span><span class="n">regular</span><span class="p">,</span><span class="n">pure_instructions</span>
<span class="n">Filename</span><span class="p">:</span> <span class="n">none</span>
<span class="n">Source</span> <span class="n">line</span><span class="p">:</span> <span class="mi">3</span>
<span class="n">push</span> <span class="n">RBP</span>
<span class="n">mov</span> <span class="n">RBP</span><span class="p">,</span> <span class="n">RSP</span>
<span class="n">test</span> <span class="n">RSI</span><span class="p">,</span> <span class="n">RSI</span>
<span class="n">jle</span> <span class="mi">22</span>
<span class="n">mov</span> <span class="n">EAX</span><span class="p">,</span> <span class="mi">1</span>
<span class="n">Source</span> <span class="n">line</span><span class="p">:</span> <span class="mi">3</span>
<span class="n">lea</span> <span class="n">RDI</span><span class="p">,</span> <span class="n">QWORD</span> <span class="n">PTR</span> <span class="p">[</span><span class="n">RDI</span> <span class="o">+</span> <span class="mi">4</span><span class="o">*</span><span class="n">RDI</span> <span class="o">-</span> <span class="mi">1</span><span class="p">]</span>
<span class="n">inc</span> <span class="n">RAX</span>
<span class="n">cmp</span> <span class="n">RAX</span><span class="p">,</span> <span class="n">RSI</span>
<span class="n">Source</span> <span class="n">line</span><span class="p">:</span> <span class="mi">2</span>
<span class="n">jle</span> <span class="o">-</span><span class="mi">17</span>
<span class="n">Source</span> <span class="n">line</span><span class="p">:</span> <span class="mi">5</span>
<span class="n">mov</span> <span class="n">RAX</span><span class="p">,</span> <span class="n">RDI</span>
<span class="n">pop</span> <span class="n">RBP</span>
<span class="n">ret</span>
</pre></div>
</div>
<p>Since the call to <tt class="docutils literal"><span class="pre">f</span></tt> gets inlined, the loop body ends up being just a
single <tt class="docutils literal"><span class="pre">lea</span></tt> instruction. Next, consider what happens if we make the number
of loop iterations fixed:</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"> g</span><span class="p">(</span><span class="n">k</span><span class="p">)</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="n">k</span> <span class="o">=</span> <span class="n">f</span><span class="p">(</span><span class="n">k</span><span class="p">)</span>
<span class="k">end</span>
<span class="k">return</span> <span class="n">k</span>
<span class="k">end</span>
<span class="n">g</span> <span class="p">(</span><span class="n">generic</span> <span class="k">function</span><span class="nf"> with</span> <span class="mi">2</span> <span class="n">methods</span><span class="p">)</span>
<span class="n">julia</span><span class="o">></span> <span class="n">code_native</span><span class="p">(</span><span class="n">g</span><span class="p">,(</span><span class="kt">Int</span><span class="p">,))</span>
<span class="o">.</span><span class="n">section</span> <span class="n">__TEXT</span><span class="p">,</span><span class="n">__text</span><span class="p">,</span><span class="n">regular</span><span class="p">,</span><span class="n">pure_instructions</span>
<span class="n">Filename</span><span class="p">:</span> <span class="n">none</span>
<span class="n">Source</span> <span class="n">line</span><span class="p">:</span> <span class="mi">3</span>
<span class="n">push</span> <span class="n">RBP</span>
<span class="n">mov</span> <span class="n">RBP</span><span class="p">,</span> <span class="n">RSP</span>
<span class="n">Source</span> <span class="n">line</span><span class="p">:</span> <span class="mi">3</span>
<span class="n">imul</span> <span class="n">RAX</span><span class="p">,</span> <span class="n">RDI</span><span class="p">,</span> <span class="mi">9765625</span>
<span class="n">add</span> <span class="n">RAX</span><span class="p">,</span> <span class="o">-</span><span class="mi">2441406</span>
<span class="n">Source</span> <span class="n">line</span><span class="p">:</span> <span class="mi">5</span>
<span class="n">pop</span> <span class="n">RBP</span>
<span class="n">ret</span>
</pre></div>
</div>
<p>Because the compiler knows that integer addition and multiplication are
associative and that multiplication distributes over addition – neither of
which is true of saturating arithmetic – it can optimize the entire loop down
to just a multiply and an add. Saturated arithmetic completely defeats this
kind of optimization since associativity and distributivity can fail at each
loop iteration, causing different outcomes depending on which iteration the
failure occurs in. The compiler can unroll the loop, but it cannot
algebraically reduce multiple operations into fewer equivalent operations.</p>
<p>Saturated integer arithmetic is just one example of a really poor choice of
language semantics that completely prevents effective performance
optimization. There are many things that are difficult about C programming,
but integer overflow is <em>not</em> one of them – especially on 64-bit systems. If
my integers really might get bigger than 2^63-1, I can easily predict that. Am
I looping over a number of actual things that are stored in the computer? Then
it’s not going to get that big. This is guaranteed, since I don’t have that
much memory. Am I counting things that occur in the real world? Unless they’re
grains of sand or atoms in the universe, 2^63-1 is going to be plenty big. Am
I computing a factorial? Then sure, they might get that big – I should use a
<tt class="docutils literal"><span class="pre">BigInt</span></tt>. See? Easy to distinguish.</p>
</div>
<div class="section" id="how-do-abstract-or-ambiguous-fields-in-types-interact-with-the-compiler">
<span id="man-abstract-fields"></span><h3>How do “abstract” or ambiguous fields in types interact with the compiler?<a class="headerlink" href="#how-do-abstract-or-ambiguous-fields-in-types-interact-with-the-compiler" title="Permalink to this headline">¶</a></h3>
<p>Types can be declared without specifying the types of their fields:</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"> MyAmbiguousType</span>
<span class="n">a</span>
<span class="k">end</span>
</pre></div>
</div>
<p>This allows <tt class="docutils literal"><span class="pre">a</span></tt> to be of any type. This can often be useful, but it
does have a downside: for objects of type <tt class="docutils literal"><span class="pre">MyAmbiguousType</span></tt>, the
compiler will not be able to generate high-performance code. The
reason is that the compiler uses the types of objects, not their
values, to determine how to build code. Unfortunately, very little can
be inferred about an object of type <tt class="docutils literal"><span class="pre">MyAmbiguousType</span></tt>:</p>
<div class="highlight-julia"><div class="highlight"><pre><span class="n">julia</span><span class="o">></span> <span class="n">b</span> <span class="o">=</span> <span class="n">MyAmbiguousType</span><span class="p">(</span><span class="s">"Hello"</span><span class="p">)</span>
<span class="n">MyAmbiguousType</span><span class="p">(</span><span class="s">"Hello"</span><span class="p">)</span>
<span class="n">julia</span><span class="o">></span> <span class="n">c</span> <span class="o">=</span> <span class="n">MyAmbiguousType</span><span class="p">(</span><span class="mi">17</span><span class="p">)</span>
<span class="n">MyAmbiguousType</span><span class="p">(</span><span class="mi">17</span><span class="p">)</span>
<span class="n">julia</span><span class="o">></span> <span class="nb">typeof</span><span class="p">(</span><span class="n">b</span><span class="p">)</span>
<span class="n">MyAmbiguousType</span> <span class="p">(</span><span class="n">constructor</span> <span class="n">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="nb">typeof</span><span class="p">(</span><span class="n">c</span><span class="p">)</span>
<span class="n">MyAmbiguousType</span> <span class="p">(</span><span class="n">constructor</span> <span class="n">with</span> <span class="mi">1</span> <span class="n">method</span><span class="p">)</span>
</pre></div>
</div>
<p><tt class="docutils literal"><span class="pre">b</span></tt> and <tt class="docutils literal"><span class="pre">c</span></tt> have the same type, yet their underlying
representation of data in memory is very different. Even if you stored
just numeric values in field <tt class="docutils literal"><span class="pre">a</span></tt>, the fact that the memory
representation of a <tt class="docutils literal"><span class="pre">Uint8</span></tt> differs from a <tt class="docutils literal"><span class="pre">Float64</span></tt> also means
that the CPU needs to handle them using two different kinds of
instructions. Since the required information is not available in the
type, such decisions have to be made at run-time. This slows
performance.</p>
<p>You can do better by declaring the type of <tt class="docutils literal"><span class="pre">a</span></tt>. Here, we are focused
on the case where <tt class="docutils literal"><span class="pre">a</span></tt> might be any one of several types, in which
case the natural solution is to use parameters. For example:</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"> MyType</span><span class="p">{</span><span class="n">T</span><span class="o"><:</span><span class="n">FloatingPoint</span><span class="p">}</span>
<span class="n">a</span><span class="p">::</span><span class="n">T</span>
<span class="k">end</span>
</pre></div>
</div>
<p>This is a better choice than</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"> MyStillAmbiguousType</span>
<span class="n">a</span><span class="p">::</span><span class="n">FloatingPoint</span>
<span class="k">end</span>
</pre></div>
</div>
<p>because the first version specifies the type of <tt class="docutils literal"><span class="pre">a</span></tt> from the type of
the wrapper object. For example:</p>
<div class="highlight-julia"><div class="highlight"><pre><span class="n">julia</span><span class="o">></span> <span class="n">m</span> <span class="o">=</span> <span class="n">MyType</span><span class="p">(</span><span class="mf">3.2</span><span class="p">)</span>
<span class="n">MyType</span><span class="p">{</span><span class="kt">Float64</span><span class="p">}(</span><span class="mf">3.2</span><span class="p">)</span>
<span class="n">julia</span><span class="o">></span> <span class="n">t</span> <span class="o">=</span> <span class="n">MyStillAmbiguousType</span><span class="p">(</span><span class="mf">3.2</span><span class="p">)</span>
<span class="n">MyStillAmbiguousType</span><span class="p">(</span><span class="mf">3.2</span><span class="p">)</span>
<span class="n">julia</span><span class="o">></span> <span class="nb">typeof</span><span class="p">(</span><span class="n">m</span><span class="p">)</span>
<span class="n">MyType</span><span class="p">{</span><span class="kt">Float64</span><span class="p">}</span> <span class="p">(</span><span class="n">constructor</span> <span class="n">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="nb">typeof</span><span class="p">(</span><span class="n">t</span><span class="p">)</span>
<span class="n">MyStillAmbiguousType</span> <span class="p">(</span><span class="n">constructor</span> <span class="n">with</span> <span class="mi">2</span> <span class="n">methods</span><span class="p">)</span>
</pre></div>
</div>
<p>The type of field <tt class="docutils literal"><span class="pre">a</span></tt> can be readily determined from the type of
<tt class="docutils literal"><span class="pre">m</span></tt>, but not from the type of <tt class="docutils literal"><span class="pre">t</span></tt>. Indeed, in <tt class="docutils literal"><span class="pre">t</span></tt> it’s possible
to change the type of field <tt class="docutils literal"><span class="pre">a</span></tt>:</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">t</span><span class="o">.</span><span class="n">a</span><span class="p">)</span>
<span class="kt">Float64</span>
<span class="n">julia</span><span class="o">></span> <span class="n">t</span><span class="o">.</span><span class="n">a</span> <span class="o">=</span> <span class="mf">4.5f0</span>
<span class="mf">4.5f0</span>
<span class="n">julia</span><span class="o">></span> <span class="nb">typeof</span><span class="p">(</span><span class="n">t</span><span class="o">.</span><span class="n">a</span><span class="p">)</span>
<span class="kt">Float32</span>
</pre></div>
</div>
<p>In contrast, once <tt class="docutils literal"><span class="pre">m</span></tt> is constructed, the type of <tt class="docutils literal"><span class="pre">m.a</span></tt> cannot
change:</p>
<div class="highlight-julia"><div class="highlight"><pre><span class="n">julia</span><span class="o">></span> <span class="n">m</span><span class="o">.</span><span class="n">a</span> <span class="o">=</span> <span class="mf">4.5f0</span>
<span class="mf">4.5</span>
<span class="n">julia</span><span class="o">></span> <span class="nb">typeof</span><span class="p">(</span><span class="n">m</span><span class="o">.</span><span class="n">a</span><span class="p">)</span>
<span class="kt">Float64</span>
</pre></div>
</div>
<p>The fact that the type of <tt class="docutils literal"><span class="pre">m.a</span></tt> is known from <tt class="docutils literal"><span class="pre">m</span></tt>‘s type—coupled
with the fact that its type cannot change mid-function—allows the
compiler to generate highly-optimized code for objects like <tt class="docutils literal"><span class="pre">m</span></tt> but
not for objects like <tt class="docutils literal"><span class="pre">t</span></tt>.</p>
<p>Of course, all of this is true only if we construct <tt class="docutils literal"><span class="pre">m</span></tt> with a
concrete type. We can break this by explicitly constructing it with
an abstract type:</p>
<div class="highlight-julia"><div class="highlight"><pre><span class="n">julia</span><span class="o">></span> <span class="n">m</span> <span class="o">=</span> <span class="n">MyType</span><span class="p">{</span><span class="n">FloatingPoint</span><span class="p">}(</span><span class="mf">3.2</span><span class="p">)</span>
<span class="n">MyType</span><span class="p">{</span><span class="n">FloatingPoint</span><span class="p">}(</span><span class="mf">3.2</span><span class="p">)</span>
<span class="n">julia</span><span class="o">></span> <span class="nb">typeof</span><span class="p">(</span><span class="n">m</span><span class="o">.</span><span class="n">a</span><span class="p">)</span>
<span class="kt">Float64</span>
<span class="n">julia</span><span class="o">></span> <span class="n">m</span><span class="o">.</span><span class="n">a</span> <span class="o">=</span> <span class="mf">4.5f0</span>
<span class="mf">4.5f0</span>
<span class="n">julia</span><span class="o">></span> <span class="nb">typeof</span><span class="p">(</span><span class="n">m</span><span class="o">.</span><span class="n">a</span><span class="p">)</span>
<span class="kt">Float32</span>
</pre></div>
</div>
<p>For all practical purposes, such objects behave identically to those
of <tt class="docutils literal"><span class="pre">MyStillAmbiguousType</span></tt>.</p>
<p>It’s quite instructive to compare the sheer amount code generated for
a simple function</p>
<div class="highlight-julia"><div class="highlight"><pre><span class="n">func</span><span class="p">(</span><span class="n">m</span><span class="p">::</span><span class="n">MyType</span><span class="p">)</span> <span class="o">=</span> <span class="n">m</span><span class="o">.</span><span class="n">a</span><span class="o">+</span><span class="mi">1</span>
</pre></div>
</div>
<p>using</p>
<div class="highlight-julia"><div class="highlight"><pre><span class="n">code_llvm</span><span class="p">(</span><span class="n">func</span><span class="p">,(</span><span class="n">MyType</span><span class="p">{</span><span class="kt">Float64</span><span class="p">},))</span>
<span class="n">code_llvm</span><span class="p">(</span><span class="n">func</span><span class="p">,(</span><span class="n">MyType</span><span class="p">{</span><span class="n">FloatingPoint</span><span class="p">},))</span>
<span class="n">code_llvm</span><span class="p">(</span><span class="n">func</span><span class="p">,(</span><span class="n">MyType</span><span class="p">,))</span>
</pre></div>
</div>
<p>For reasons of length the results are not shown here, but you may wish
to try this yourself. Because the type is fully-specified in the first
case, the compiler doesn’t need to generate any code to resolve the
type at run-time. This results in shorter and faster code.</p>
</div>
<div class="section" id="how-should-i-declare-abstract-container-type-fields">
<span id="man-abstract-container-type"></span><h3>How should I declare “abstract container type” fields?<a class="headerlink" href="#how-should-i-declare-abstract-container-type-fields" title="Permalink to this headline">¶</a></h3>
<p>The same best practices that apply in the <a class="reference external" href="#man-abstract-fields">previous section</a> also work for container types:</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"> MySimpleContainer</span><span class="p">{</span><span class="n">A</span><span class="o"><:</span><span class="n">AbstractVector</span><span class="p">}</span>
<span class="n">a</span><span class="p">::</span><span class="n">A</span>
<span class="k">end</span>
<span class="n">julia</span><span class="o">></span> <span class="k">type</span><span class="nc"> MyAmbiguousContainer</span><span class="p">{</span><span class="n">T</span><span class="p">}</span>
<span class="n">a</span><span class="p">::</span><span class="n">AbstractVector</span><span class="p">{</span><span class="n">T</span><span class="p">}</span>
<span class="k">end</span>
</pre></div>
</div>
<p>For example:</p>
<div class="highlight-julia"><div class="highlight"><pre><span class="n">julia</span><span class="o">></span> <span class="n">c</span> <span class="o">=</span> <span class="n">MySimpleContainer</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="n">julia</span><span class="o">></span> <span class="nb">typeof</span><span class="p">(</span><span class="n">c</span><span class="p">)</span>
<span class="n">MySimpleContainer</span><span class="p">{</span><span class="n">UnitRange</span><span class="p">{</span><span class="kt">Int64</span><span class="p">}}</span> <span class="p">(</span><span class="n">constructor</span> <span class="n">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">c</span> <span class="o">=</span> <span class="n">MySimpleContainer</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="n">julia</span><span class="o">></span> <span class="nb">typeof</span><span class="p">(</span><span class="n">c</span><span class="p">)</span>
<span class="n">MySimpleContainer</span><span class="p">{</span><span class="n">Array</span><span class="p">{</span><span class="kt">Int64</span><span class="p">,</span><span class="mi">1</span><span class="p">}}</span> <span class="p">(</span><span class="n">constructor</span> <span class="n">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">b</span> <span class="o">=</span> <span class="n">MyAmbiguousContainer</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="n">julia</span><span class="o">></span> <span class="nb">typeof</span><span class="p">(</span><span class="n">b</span><span class="p">)</span>
<span class="n">MyAmbiguousContainer</span><span class="p">{</span><span class="kt">Int64</span><span class="p">}</span> <span class="p">(</span><span class="n">constructor</span> <span class="n">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">b</span> <span class="o">=</span> <span class="n">MyAmbiguousContainer</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="n">julia</span><span class="o">></span> <span class="nb">typeof</span><span class="p">(</span><span class="n">b</span><span class="p">)</span>
<span class="n">MyAmbiguousContainer</span><span class="p">{</span><span class="kt">Int64</span><span class="p">}</span> <span class="p">(</span><span class="n">constructor</span> <span class="n">with</span> <span class="mi">1</span> <span class="n">method</span><span class="p">)</span>
</pre></div>
</div>
<p>For <tt class="docutils literal"><span class="pre">MySimpleContainer</span></tt>, the object is fully-specified by its type
and parameters, so the compiler can generate optimized functions. In
most instances, this will probably suffice.</p>
<p>While the compiler can now do its job perfectly well, there are cases
where <em>you</em> might wish that your code could do different things
depending on the <em>element type</em> of <tt class="docutils literal"><span class="pre">a</span></tt>. Usually the best way to
achieve this is to wrap your specific operation (here, <tt class="docutils literal"><span class="pre">foo</span></tt>) in a
separate function:</p>
<div class="highlight-julia"><div class="highlight"><pre><span class="k">function</span><span class="nf"> sumfoo</span><span class="p">(</span><span class="n">c</span><span class="p">::</span><span class="n">MySimpleContainer</span><span class="p">)</span>
<span class="n">s</span> <span class="o">=</span> <span class="mi">0</span>
<span class="k">for</span> <span class="n">x</span> <span class="k">in</span> <span class="n">c</span><span class="o">.</span><span class="n">a</span>
<span class="n">s</span> <span class="o">+=</span> <span class="n">foo</span><span class="p">(</span><span class="n">x</span><span class="p">)</span>
<span class="k">end</span>
<span class="n">s</span>
<span class="k">end</span>
<span class="n">foo</span><span class="p">(</span><span class="n">x</span><span class="p">::</span><span class="n">Integer</span><span class="p">)</span> <span class="o">=</span> <span class="n">x</span>
<span class="n">foo</span><span class="p">(</span><span class="n">x</span><span class="p">::</span><span class="n">FloatingPoint</span><span class="p">)</span> <span class="o">=</span> <span class="n">round</span><span class="p">(</span><span class="n">x</span><span class="p">)</span>
</pre></div>
</div>
<p>This keeps things simple, while allowing the compiler to generate
optimized code in all cases.</p>
<p>However, there are cases where you may need to declare different
versions of the outer function for different element types of
<tt class="docutils literal"><span class="pre">a</span></tt>. You could do it like this:</p>
<div class="highlight-julia"><div class="highlight"><pre><span class="k">function</span><span class="nf"> myfun</span><span class="p">{</span><span class="n">T</span><span class="o"><:</span><span class="n">FloatingPoint</span><span class="p">}(</span><span class="n">c</span><span class="p">::</span><span class="n">MySimpleContainer</span><span class="p">{</span><span class="n">Vector</span><span class="p">{</span><span class="n">T</span><span class="p">}})</span>
<span class="o">...</span>
<span class="k">end</span>
<span class="k">function</span><span class="nf"> myfun</span><span class="p">{</span><span class="n">T</span><span class="o"><:</span><span class="n">Integer</span><span class="p">}(</span><span class="n">c</span><span class="p">::</span><span class="n">MySimpleContainer</span><span class="p">{</span><span class="n">Vector</span><span class="p">{</span><span class="n">T</span><span class="p">}})</span>
<span class="o">...</span>
<span class="k">end</span>
</pre></div>
</div>
<p>This works fine for <tt class="docutils literal"><span class="pre">Vector{T}</span></tt>, but we’d also have to write
explicit versions for <tt class="docutils literal"><span class="pre">UnitRange{T}</span></tt> or other abstract types. To
prevent such tedium, you can use two parameters in the declaration of
<tt class="docutils literal"><span class="pre">MyContainer</span></tt>:</p>
<div class="highlight-julia"><div class="highlight"><pre><span class="k">type</span><span class="nc"> MyContainer</span><span class="p">{</span><span class="n">T</span><span class="p">,</span> <span class="n">A</span><span class="o"><:</span><span class="n">AbstractVector</span><span class="p">}</span>
<span class="n">a</span><span class="p">::</span><span class="n">A</span>
<span class="k">end</span>
<span class="n">MyContainer</span><span class="p">(</span><span class="n">v</span><span class="p">::</span><span class="n">AbstractVector</span><span class="p">)</span> <span class="o">=</span> <span class="n">MyContainer</span><span class="p">{</span><span class="n">eltype</span><span class="p">(</span><span class="n">v</span><span class="p">),</span> <span class="nb">typeof</span><span class="p">(</span><span class="n">v</span><span class="p">)}(</span><span class="n">v</span><span class="p">)</span>
<span class="n">julia</span><span class="o">></span> <span class="n">b</span> <span class="o">=</span> <span class="n">MyContainer</span><span class="p">(</span><span class="mf">1.3</span><span class="p">:</span><span class="mi">5</span><span class="p">);</span>
<span class="n">julia</span><span class="o">></span> <span class="nb">typeof</span><span class="p">(</span><span class="n">b</span><span class="p">)</span>
<span class="n">MyContainer</span><span class="p">{</span><span class="kt">Float64</span><span class="p">,</span><span class="n">UnitRange</span><span class="p">{</span><span class="kt">Float64</span><span class="p">}}</span>
</pre></div>
</div>
<p>Note the somewhat surprising fact that <tt class="docutils literal"><span class="pre">T</span></tt> doesn’t appear in the
declaration of field <tt class="docutils literal"><span class="pre">a</span></tt>, a point that we’ll return to in a moment.
With this approach, one can write functions such as:</p>
<div class="highlight-julia"><div class="highlight"><pre><span class="k">function</span><span class="nf"> myfunc</span><span class="p">{</span><span class="n">T</span><span class="o"><:</span><span class="n">Integer</span><span class="p">,</span> <span class="n">A</span><span class="o"><:</span><span class="n">AbstractArray</span><span class="p">}(</span><span class="n">c</span><span class="p">::</span><span class="n">MyContainer</span><span class="p">{</span><span class="n">T</span><span class="p">,</span><span class="n">A</span><span class="p">})</span>
<span class="k">return</span> <span class="n">c</span><span class="o">.</span><span class="n">a</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span><span class="o">+</span><span class="mi">1</span>
<span class="k">end</span>
<span class="c"># Note: because we can only define MyContainer for</span>
<span class="c"># A<:AbstractArray, and any unspecified parameters are arbitrary,</span>
<span class="c"># the previous could have been written more succinctly as</span>
<span class="c"># function myfunc{T<:Integer}(c::MyContainer{T})</span>
<span class="k">function</span><span class="nf"> myfunc</span><span class="p">{</span><span class="n">T</span><span class="o"><:</span><span class="n">FloatingPoint</span><span class="p">}(</span><span class="n">c</span><span class="p">::</span><span class="n">MyContainer</span><span class="p">{</span><span class="n">T</span><span class="p">})</span>
<span class="k">return</span> <span class="n">c</span><span class="o">.</span><span class="n">a</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span><span class="o">+</span><span class="mi">2</span>
<span class="k">end</span>
<span class="k">function</span><span class="nf"> myfunc</span><span class="p">{</span><span class="n">T</span><span class="o"><:</span><span class="n">Integer</span><span class="p">}(</span><span class="n">c</span><span class="p">::</span><span class="n">MyContainer</span><span class="p">{</span><span class="n">T</span><span class="p">,</span><span class="n">Vector</span><span class="p">{</span><span class="n">T</span><span class="p">}})</span>
<span class="k">return</span> <span class="n">c</span><span class="o">.</span><span class="n">a</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span><span class="o">+</span><span class="mi">3</span>
<span class="k">end</span>
<span class="n">julia</span><span class="o">></span> <span class="n">myfunc</span><span class="p">(</span><span class="n">MyContainer</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="mi">2</span>
<span class="n">julia</span><span class="o">></span> <span class="n">myfunc</span><span class="p">(</span><span class="n">MyContainer</span><span class="p">(</span><span class="mf">1.0</span><span class="p">:</span><span class="mi">3</span><span class="p">))</span>
<span class="mf">3.0</span>
<span class="n">julia</span><span class="o">></span> <span class="n">myfunc</span><span class="p">(</span><span class="n">MyContainer</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="mi">4</span>
</pre></div>
</div>
<p>As you can see, with this approach it’s possible to specialize on both
the element type <tt class="docutils literal"><span class="pre">T</span></tt> and the array type <tt class="docutils literal"><span class="pre">A</span></tt>.</p>
<p>However, there’s one remaining hole: we haven’t enforced that <tt class="docutils literal"><span class="pre">A</span></tt>
has element type <tt class="docutils literal"><span class="pre">T</span></tt>, so it’s perfectly possible to construct an
object like this:</p>
<div class="highlight-julia"><div class="highlight"><pre><span class="n">julia</span><span class="o">></span> <span class="n">b</span> <span class="o">=</span> <span class="n">MyContainer</span><span class="p">{</span><span class="kt">Int64</span><span class="p">,</span> <span class="n">UnitRange</span><span class="p">{</span><span class="kt">Float64</span><span class="p">}}(</span><span class="mf">1.3</span><span class="p">:</span><span class="mi">5</span><span class="p">);</span>
<span class="n">julia</span><span class="o">></span> <span class="nb">typeof</span><span class="p">(</span><span class="n">b</span><span class="p">)</span>
<span class="n">MyContainer</span><span class="p">{</span><span class="kt">Int64</span><span class="p">,</span><span class="n">UnitRange</span><span class="p">{</span><span class="kt">Float64</span><span class="p">}}</span>
</pre></div>
</div>
<p>To prevent this, we can add an inner constructor:</p>
<div class="highlight-julia"><div class="highlight"><pre><span class="k">type</span><span class="nc"> MyBetterContainer</span><span class="p">{</span><span class="n">T</span><span class="o"><:</span><span class="n">Real</span><span class="p">,</span> <span class="n">A</span><span class="o"><:</span><span class="n">AbstractVector</span><span class="p">}</span>
<span class="n">a</span><span class="p">::</span><span class="n">A</span>
<span class="n">MyBetterContainer</span><span class="p">(</span><span class="n">v</span><span class="p">::</span><span class="n">AbstractVector</span><span class="p">{</span><span class="n">T</span><span class="p">})</span> <span class="o">=</span> <span class="nb">new</span><span class="p">(</span><span class="n">v</span><span class="p">)</span>
<span class="k">end</span>
<span class="n">MyBetterContainer</span><span class="p">(</span><span class="n">v</span><span class="p">::</span><span class="n">AbstractVector</span><span class="p">)</span> <span class="o">=</span> <span class="n">MyBetterContainer</span><span class="p">{</span><span class="n">eltype</span><span class="p">(</span><span class="n">v</span><span class="p">),</span><span class="nb">typeof</span><span class="p">(</span><span class="n">v</span><span class="p">)}(</span><span class="n">v</span><span class="p">)</span>
<span class="n">julia</span><span class="o">></span> <span class="n">b</span> <span class="o">=</span> <span class="n">MyBetterContainer</span><span class="p">(</span><span class="mf">1.3</span><span class="p">:</span><span class="mi">5</span><span class="p">);</span>
<span class="n">julia</span><span class="o">></span> <span class="nb">typeof</span><span class="p">(</span><span class="n">b</span><span class="p">)</span>
<span class="n">MyBetterContainer</span><span class="p">{</span><span class="kt">Float64</span><span class="p">,</span><span class="n">UnitRange</span><span class="p">{</span><span class="kt">Float64</span><span class="p">}}</span>
<span class="n">julia</span><span class="o">></span> <span class="n">b</span> <span class="o">=</span> <span class="n">MyBetterContainer</span><span class="p">{</span><span class="kt">Int64</span><span class="p">,</span> <span class="n">UnitRange</span><span class="p">{</span><span class="kt">Float64</span><span class="p">}}(</span><span class="mf">1.3</span><span class="p">:</span><span class="mi">5</span><span class="p">);</span>
<span class="n">ERROR</span><span class="p">:</span> <span class="n">no</span> <span class="n">method</span> <span class="n">MyBetterContainer</span><span class="p">(</span><span class="n">UnitRange</span><span class="p">{</span><span class="kt">Float64</span><span class="p">},)</span>
</pre></div>
</div>
<p>The inner constructor requires that the element type of <tt class="docutils literal"><span class="pre">A</span></tt> be <tt class="docutils literal"><span class="pre">T</span></tt>.</p>
</div>
</div>
<div class="section" id="nothingness-and-missing-values">
<h2>Nothingness and missing values<a class="headerlink" href="#nothingness-and-missing-values" title="Permalink to this headline">¶</a></h2>
<div class="section" id="how-does-null-or-nothingness-work-in-julia">
<h3>How does “null” or “nothingness” work in Julia?<a class="headerlink" href="#how-does-null-or-nothingness-work-in-julia" title="Permalink to this headline">¶</a></h3>
<p>Unlike many languages (for example, C and Java), Julia does not have a
“null” value. When a reference (variable, object field, or array element)
is uninitialized, accessing it will immediately throw an error. This
situation can be detected using the <tt class="docutils literal"><span class="pre">isdefined</span></tt> function.</p>
<p>Some functions are used only for their side effects, and do not need to
return a value. In these cases, the convention is to return the value
<tt class="docutils literal"><span class="pre">nothing</span></tt>, which is just a singleton object of type <tt class="docutils literal"><span class="pre">Nothing</span></tt>. This
is an ordinary type with no fields; there is nothing special about it
except for this convention, and that the REPL does not print anything
for it. Some language constructs that would not otherwise have a value
also yield <tt class="docutils literal"><span class="pre">nothing</span></tt>, for example <tt class="docutils literal"><span class="pre">if</span> <span class="pre">false;</span> <span class="pre">end</span></tt>.</p>
<p>Note that <tt class="docutils literal"><span class="pre">Nothing</span></tt> (uppercase) is the type of <tt class="docutils literal"><span class="pre">nothing</span></tt>, and should
only be used in a context where a type is required (e.g. a declaration).</p>
<p>You may occasionally see <tt class="docutils literal"><span class="pre">None</span></tt>, which is quite different. It is the
empty (or “bottom”) type, a type with no values and no subtypes (except
itself). You will generally not need to use this type.</p>
<p>The empty tuple (<tt class="docutils literal"><span class="pre">()</span></tt>) is another form of nothingness. But, it should not
really be thought of as nothing but rather a tuple of zero values.</p>
</div>
</div>
<div class="section" id="julia-releases">
<h2>Julia Releases<a class="headerlink" href="#julia-releases" title="Permalink to this headline">¶</a></h2>
<div class="section" id="do-i-want-to-use-a-release-beta-or-nightly-version-of-julia">
<h3>Do I want to use a release, beta, or nightly version of Julia?<a class="headerlink" href="#do-i-want-to-use-a-release-beta-or-nightly-version-of-julia" title="Permalink to this headline">¶</a></h3>
<p>You may prefer the release version of Julia if you are looking for a stable code base. Releases generally occur every 6 months, giving you a stable platform for writing code.</p>
<p>You may prefer the beta version of Julia if you don’t mind being slightly behind the latest bugfixes and changes, but find the slightly faster rate of changes more appealing. Additionally, these binaries are tested before they are published to ensure they are fully functional.</p>
<p>You may prefer the nightly version of Julia if you want to take advantage of the latest updates to the language, and don’t mind if the version available today occasionally doesn’t actually work.</p>
<p>Finally, you may also consider building Julia from source for yourself. This option is mainly for those individuals who are comfortable at the command line, or interested in learning. If this describes you, you may also be interested in reading our <a class="reference external" href="https://github.com/JuliaLang/julia/blob/master/CONTRIBUTING.md">guidelines for contributing</a>.</p>
<p>Links to each of these download types can be found on the download page at <a class="reference external" href="http://julialang.org/downloads/">http://julialang.org/downloads/</a>. Note that not all versions of Julia are available for all platforms.</p>
</div>
<div class="section" id="when-are-deprecated-functions-removed">
<h3>When are deprecated functions removed?<a class="headerlink" href="#when-are-deprecated-functions-removed" title="Permalink to this headline">¶</a></h3>
<p>Deprecated functions are removed after the subsequent release. For example, functions marked as deprecated in the 0.1 release will not be available starting with the 0.2 release.</p>
</div>
</div>
<div class="section" id="developing-julia">
<h2>Developing Julia<a class="headerlink" href="#developing-julia" title="Permalink to this headline">¶</a></h2>
<div class="section" id="how-do-i-debug-julia-s-c-code-running-the-julia-repl-from-within-a-debugger-like-gdb">
<h3>How do I debug julia’s C code? (running the julia REPL from within a debugger like gdb)<a class="headerlink" href="#how-do-i-debug-julia-s-c-code-running-the-julia-repl-from-within-a-debugger-like-gdb" title="Permalink to this headline">¶</a></h3>
<p>First, you should build the debug version of julia with <tt class="docutils literal"><span class="pre">make</span>
<span class="pre">debug</span></tt>. Below, lines starting with <tt class="docutils literal"><span class="pre">(gdb)</span></tt> mean things you should
type at the gdb prompt.</p>
<div class="section" id="from-the-shell">
<h4>From the shell<a class="headerlink" href="#from-the-shell" title="Permalink to this headline">¶</a></h4>
<p>The main challenge is that Julia and gdb each need to have their own
terminal, to allow you to interact with them both. One approach is to
use gdb’s <tt class="docutils literal"><span class="pre">attach</span></tt> functionality to debug an already-running julia
session. However, on many systems you’ll need root access to get this
to work. What follows is a method that can be implemented with just
user-level permissions.</p>
<p>The first time you do this, you’ll need to define a script, here
called <tt class="docutils literal"><span class="pre">oterm</span></tt>, containing the following lines:</p>
<div class="highlight-julia"><div class="highlight"><pre><span class="n">ps</span>
<span class="n">sleep</span> <span class="mi">600000</span>
</pre></div>
</div>
<p>Make it executable with <tt class="docutils literal"><span class="pre">chmod</span> <span class="pre">+x</span> <span class="pre">oterm</span></tt>.</p>
<p>Now:</p>
<ul class="simple">
<li>From a shell (called shell 1), type <tt class="docutils literal"><span class="pre">xterm</span> <span class="pre">-e</span> <span class="pre">oterm</span> <span class="pre">&</span></tt>. You’ll see
a new window pop up; this will be called terminal 2.</li>
<li>From within shell 1, <tt class="docutils literal"><span class="pre">gdb</span> <span class="pre">julia-debug</span></tt>. You can find this
executable within <tt class="docutils literal"><span class="pre">julia/usr/bin</span></tt>.</li>
<li>From within shell 1, <tt class="docutils literal"><span class="pre">(gdb)</span> <span class="pre">tty</span> <span class="pre">/dev/pts/#</span></tt> where <tt class="docutils literal"><span class="pre">#</span></tt> is the
number shown after <tt class="docutils literal"><span class="pre">pts/</span></tt> in terminal 2.</li>
<li>From within shell 1, <tt class="docutils literal"><span class="pre">(gdb)</span> <span class="pre">run</span></tt></li>
<li>From within terminal 2, issue any preparatory commands in Julia that
you need to get to the step you want to debug</li>
<li>From within shell 1, hit Ctrl-C</li>
<li>From within shell 1, insert your breakpoint, e.g., <tt class="docutils literal"><span class="pre">(gdb)</span> <span class="pre">b</span> <span class="pre">codegen.cpp:2244</span></tt></li>
<li>From within shell 1, <tt class="docutils literal"><span class="pre">(gdb)</span> <span class="pre">c</span></tt> to resume execution of julia</li>
<li>From within terminal 2, issue the command that you want to
debug. Shell 1 will stop at your breakpoint.</li>
</ul>
</div>
<div class="section" id="within-emacs">
<h4>Within emacs<a class="headerlink" href="#within-emacs" title="Permalink to this headline">¶</a></h4>
<ul class="simple">
<li><tt class="docutils literal"><span class="pre">M-x</span> <span class="pre">gdb</span></tt>, then enter <tt class="docutils literal"><span class="pre">julia-debug</span></tt> (this is easiest from
within julia/usr/bin, or you can specify the full path)</li>
<li><tt class="docutils literal"><span class="pre">(gdb)</span> <span class="pre">run</span></tt></li>
<li>Now you’ll see the Julia prompt. Run any commands in Julia you need
to get to the step you want to debug.</li>
<li>Under emacs’ “Signals” menu choose BREAK—this will return you to the <tt class="docutils literal"><span class="pre">(gdb)</span></tt> prompt</li>
<li>Set a breakpoint, e.g., <tt class="docutils literal"><span class="pre">(gdb)</span> <span class="pre">b</span> <span class="pre">codegen.cpp:2244</span></tt></li>
<li>Go back to the Julia prompt via <tt class="docutils literal"><span class="pre">(gdb)</span> <span class="pre">c</span></tt></li>
<li>Execute the Julia command you want to see running.</li>
</ul>
</div>
</div>
</div>
</div>
</div>
<footer>
<div class="rst-footer-buttons" role="navigation" aria-label="footer navigation">
<a href="noteworthy-differences.html" class="btn btn-neutral float-right" title="Noteworthy Differences from other Languages"/>Next <span class="fa fa-arrow-circle-right"></span></a>
<a href="style-guide.html" class="btn btn-neutral" title="Style Guide"><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>
