Home Explore Help
Sign In
levovix
/
Nim
mirror of https://github.com/nim-lang/Nim
Watch 1
Star 0
Fork 1
Files Issues 0 Wiki
Tree: d69e064e0c
Branches Tags
Nim
/
tut1.html

tut1.html 213 KB
History Raw

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071 
  1. <?xml version="1.0" encoding="utf-8" ?>
    2. 

  2. <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
    3. 

  3. <!--  This file is generated by Nim. -->
    4. 

  4. <html xmlns="https://www.w3.org/1999/xhtml" xml:lang="en" lang="en" data-theme="auto">
    5. 

  5. <head>
    6. 

  6. <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
    7. 

  7. <meta name="viewport" content="width=device-width, initial-scale=1.0">
    8. 

  8. <title>Nim Tutorial (Part I)</title>
    9. 

  9. 

  10. <!-- Google fonts -->
    11. 

  11. <link href='https://fonts.googleapis.com/css?family=Lato:400,600,900' rel='stylesheet' type='text/css'/>
    12. 

  12. <link href='https://fonts.googleapis.com/css?family=Source+Code+Pro:400,500,600' rel='stylesheet' type='text/css'/>
    13. 

  13. 

  14. <!-- Favicon -->
    15. 

  15. <link rel="shortcut icon" href="data:image/x-icon;base64,AAABAAEAEBAAAAEAIABoBAAAFgAAACgAAAAQAAAAIAAAAAEAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD///8A////AP///wD///8A////AP///wD///8A////AP///wD///8A////AP///wD///8A////AP///wD///8A////AP///wD///8A////AP///wD///8A////AAAAAAUAAAAF////AP///wD///8A////AP///wD///8A////AP///wD///8A////AAAAAAIAAABbAAAAlQAAAKIAAACbAAAAmwAAAKIAAACVAAAAWwAAAAL///8A////AP///wD///8A////AAAAABQAAADAAAAAYwAAAA3///8A////AP///wD///8AAAAADQAAAGMAAADAAAAAFP///wD///8A////AP///wAAAACdAAAAOv///wD///8A////AP///wD///8A////AP///wD///8AAAAAOgAAAJ3///8A////AP///wAAAAAnAAAAcP///wAAAAAoAAAASv///wD///8A////AP///wAAAABKAAAAKP///wAAAABwAAAAJ////wD///8AAAAAgQAAABwAAACIAAAAkAAAAJMAAACtAAAAFQAAABUAAACtAAAAkwAAAJAAAACIAAAAHAAAAIH///8A////AAAAAKQAAACrAAAAaP///wD///8AAAAARQAAANIAAADSAAAARf///wD///8AAAAAaAAAAKsAAACk////AAAAADMAAACcAAAAnQAAABj///8A////AP///wAAAAAYAAAAGP///wD///8A////AAAAABgAAACdAAAAnAAAADMAAAB1AAAAwwAAAP8AAADpAAAAsQAAAE4AAAAb////AP///wAAAAAbAAAATgAAALEAAADpAAAA/wAAAMMAAAB1AAAAtwAAAOkAAAD/AAAA/wAAAP8AAADvAAAA3gAAAN4AAADeAAAA3gAAAO8AAAD/AAAA/wAAAP8AAADpAAAAtwAAAGUAAAA/AAAA3wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAADfAAAAPwAAAGX///8A////AAAAAEgAAADtAAAAvwAAAL0AAADGAAAA7wAAAO8AAADGAAAAvQAAAL8AAADtAAAASP///wD///8A////AP///wD///8AAAAAO////wD///8A////AAAAAIcAAACH////AP///wD///8AAAAAO////wD///8A////AP///wD///8A////AP///wD///8A////AP///wD///8A////AP///wD///8A////AP///wD///8A////AP///wD///8A////AP///wD///8A////AP///wD///8A////AP///wD///8A////AP///wD///8A////AP///wD///8A//8AAP//AAD4HwAA7/cAAN/7AAD//wAAoYUAAJ55AACf+QAAh+EAAAAAAADAAwAA4AcAAP5/AAD//wAA//8AAA=="/>
    16. 

  16. <link rel="icon" type="image/png" sizes="32x32" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAYAAABzenr0AAAABmJLR0QA/wD/AP+gvaeTAAAACXBIWXMAAA3XAAAN1wFCKJt4AAAAB3RJTUUH4QQQEwksSS9ZWwAAAk1JREFUWMPtll2ITVEUx39nn/O7Y5qR8f05wtCUUr6ZIS++8pEnkZInPImneaCQ5METNdOkeFBKUhMPRIkHKfEuUZSUlGlKPN2TrgfncpvmnntnmlEyq1Z7t89/rf9a6+y99oZxGZf/XeIq61EdtgKXgdXA0xrYAvBjOIF1AI9zvjcC74BSpndrJPkBWDScTF8Aa4E3wDlgHbASaANmVqlcCnwHvgDvgVfAJ+AikAAvgfVZwLnSVZHZaOuKoQi3ZOMi4NkYkpe1p4J7A8BpYAD49hfIy/oqG0+hLomiKP2L5L+1ubn5115S+3OAn4EnwBlgMzCjyt6ZAnQCJ4A7wOs88iRJHvw50HoujuPBoCKwHWiosy8MdfZnAdcHk8dxXFJ3VQbQlCTJvRBCGdRbD4M6uc5glpY3eAihpN5S5w12diSEcCCEcKUO4ljdr15T76ur1FDDLIQQ3qv71EdDOe3Kxj3leRXyk+pxdWnFWod6Wt2bY3de3aSuUHcPBVimHs7mK9WrmeOF6lR1o9qnzskh2ar2qm1qizpfXaPeVGdlmGN5pb09qMxz1Xb1kLqgzn1RyH7JUXW52lr5e/Kqi9qpto7V1atuUzfnARrV7jEib1T76gG2qxdGmXyiekkt1GswPTtek0aBfJp6YySGBfWg2tPQ0FAYgf1stUfdmdcjarbYJEniKIq6gY/Aw+zWHAC+p2labGpqiorFYgGYCEzN7oQdQClN07O1/EfDyGgC0ALMBdYAi4FyK+4H3gLPsxfR1zRNi+NP7nH5J+QntnXe5B5mpfQAAAAASUVORK5CYII=">
    17. 

  17. 

  18. <!-- CSS -->
    19. 

  19. <link rel="stylesheet" type="text/css" href="nimdoc.out.css?v=2.3.1">
    20. 

  20. 

  21. <!-- JS -->
    22. 

  22. <script type="text/javascript" src="dochack.js?v=2.3.1"></script>
    23. 

  23. </head>
    24. 

  24. <body>
    25. 

  25.   <div class="document" id="documentId">
    26. 

  26.     <div class="container">
    27. 

  27.       <h1 class="title">Nim Tutorial (Part I)</h1>
    28. 

  28.       <div class="row">
    29. 

  29.   <div class="three columns">
    30. 

  30.     <div class="theme-select-wrapper">
    31. 

  31.       <label for="theme-select">Theme:&nbsp;</label>
    32. 

  32.       <select id="theme-select" onchange="setTheme(this.value)">
    33. 

  33.         <option value="auto">🌗 Match OS</option>
    34. 

  34.         <option value="dark">🌑 Dark</option>
    35. 

  35.         <option value="light">🌕 Light</option>
    36. 

  36.       </select>
    37. 

  37.     </div>
    38. 

  38.     <div id="global-links">
    39. 

  39.       <ul class="simple-boot">
    40. 

  40.         <li><a href="manual.html">Manual</a></li>
    41. 

  41.         <li><a href="lib.html">Standard library</a></li>
    42. 

  42.         <li> <a id="indexLink" href="theindex.html">Index</a></li>
    43. 

  43.         <li><a href="compiler/theindex.html">Compiler docs</a></li>
    44. 

  44.         <li><a href="https://nim-lang.github.io/fusion/theindex.html">Fusion docs</a></li>
    45. 

  45.         <li><a href="https://nim-lang.github.io/Nim/">devel</a>, <a href="https://nim-lang.org/documentation.html">stable</a></li>
    46. 

  46.       </ul>
    47. 

  47.     </div>
    48. 

  48.     <div id="searchInputDiv">
    49. 

  49.       Search: <input type="search" id="searchInput"
    50. 

  50.         oninput="search()" />
    51. 

  51.     </div>
    52. 

  52.     <div class="search-groupby">
    53. 

  53.   Group by:
    54. 

  54.   <select onchange="groupBy(this.value)">
    55. 

  55.     <option value="section">Section</option>
    56. 

  56.     <option value="type">Type</option>
    57. 

  57.   </select>
    58. 

  58. </div>
    59. 

  59. 

  60.     <ul class="simple simple-toc" id="toc-list">
    61. 

  61.   <li><a class="reference" id="introduction_toc" href="#introduction">Introduction</a></li>
    62. 

  62. <li><a class="reference" id="the-first-program_toc" href="#the-first-program">The first program</a></li>
    63. 

  63. <li><a class="reference" id="lexical-elements_toc" href="#lexical-elements">Lexical elements</a></li>
    64. 

  64. <ul class="simple"><li><a class="reference" id="lexical-elements-string-and-character-literals_toc" href="#lexical-elements-string-and-character-literals">String and character literals</a></li>
    65. 

  65. <li><a class="reference" id="lexical-elements-comments_toc" href="#lexical-elements-comments">Comments</a></li>
    66. 

  66. <li><a class="reference" id="lexical-elements-numbers_toc" href="#lexical-elements-numbers">Numbers</a></li>
    67. 

  67. </ul><li><a class="reference" id="the-var-statement_toc" href="#the-var-statement">The var statement</a></li>
    68. 

  68. <li><a class="reference" id="constants_toc" href="#constants">Constants</a></li>
    69. 

  69. <li><a class="reference" id="the-let-statement_toc" href="#the-let-statement">The let statement</a></li>
    70. 

  70. <li><a class="reference" id="the-assignment-statement_toc" href="#the-assignment-statement">The assignment statement</a></li>
    71. 

  71. <li><a class="reference" id="control-flow-statements_toc" href="#control-flow-statements">Control flow statements</a></li>
    72. 

  72. <ul class="simple"><li><a class="reference" id="control-flow-statements-if-statement_toc" href="#control-flow-statements-if-statement">If statement</a></li>
    73. 

  73. <li><a class="reference" id="control-flow-statements-case-statement_toc" href="#control-flow-statements-case-statement">Case statement</a></li>
    74. 

  74. <li><a class="reference" id="control-flow-statements-while-statement_toc" href="#control-flow-statements-while-statement">While statement</a></li>
    75. 

  75. <li><a class="reference" id="control-flow-statements-for-statement_toc" href="#control-flow-statements-for-statement">For statement</a></li>
    76. 

  76. <li><a class="reference" id="control-flow-statements-scopes-and-the-block-statement_toc" href="#control-flow-statements-scopes-and-the-block-statement">Scopes and the block statement</a></li>
    77. 

  77. <li><a class="reference" id="control-flow-statements-break-statement_toc" href="#control-flow-statements-break-statement">Break statement</a></li>
    78. 

  78. <li><a class="reference" id="control-flow-statements-continue-statement_toc" href="#control-flow-statements-continue-statement">Continue statement</a></li>
    79. 

  79. <li><a class="reference" id="control-flow-statements-when-statement_toc" href="#control-flow-statements-when-statement">When statement</a></li>
    80. 

  80. </ul><li><a class="reference" id="statements-and-indentation_toc" href="#statements-and-indentation">Statements and indentation</a></li>
    81. 

  81. <li><a class="reference" id="procedures_toc" href="#procedures">Procedures</a></li>
    82. 

  82. <ul class="simple"><li><a class="reference" id="procedures-result-variable_toc" href="#procedures-result-variable">Result variable</a></li>
    83. 

  83. <li><a class="reference" id="procedures-parameters_toc" href="#procedures-parameters">Parameters</a></li>
    84. 

  84. <li><a class="reference" id="procedures-discard-statement_toc" href="#procedures-discard-statement">Discard statement</a></li>
    85. 

  85. <li><a class="reference" id="procedures-named-arguments_toc" href="#procedures-named-arguments">Named arguments</a></li>
    86. 

  86. <li><a class="reference" id="procedures-default-values_toc" href="#procedures-default-values">Default values</a></li>
    87. 

  87. <li><a class="reference" id="procedures-overloaded-procedures_toc" href="#procedures-overloaded-procedures">Overloaded procedures</a></li>
    88. 

  88. <li><a class="reference" id="procedures-operators_toc" href="#procedures-operators">Operators</a></li>
    89. 

  89. <li><a class="reference" id="procedures-forward-declarations_toc" href="#procedures-forward-declarations">Forward declarations</a></li>
    90. 

  90. <li><a class="reference" id="procedures-funcs-and-methods_toc" href="#procedures-funcs-and-methods">Funcs and methods</a></li>
    91. 

  91. </ul><li><a class="reference" id="iterators_toc" href="#iterators">Iterators</a></li>
    92. 

  92. <li><a class="reference" id="basic-types_toc" href="#basic-types">Basic types</a></li>
    93. 

  93. <ul class="simple"><li><a class="reference" id="basic-types-booleans_toc" href="#basic-types-booleans">Booleans</a></li>
    94. 

  94. <li><a class="reference" id="basic-types-characters_toc" href="#basic-types-characters">Characters</a></li>
    95. 

  95. <li><a class="reference" id="basic-types-strings_toc" href="#basic-types-strings">Strings</a></li>
    96. 

  96. <li><a class="reference" id="basic-types-integers_toc" href="#basic-types-integers">Integers</a></li>
    97. 

  97. <li><a class="reference" id="basic-types-floats_toc" href="#basic-types-floats">Floats</a></li>
    98. 

  98. <li><a class="reference" id="basic-types-type-conversion_toc" href="#basic-types-type-conversion">Type Conversion</a></li>
    99. 

  99. </ul><li><a class="reference" id="internal-type-representation_toc" href="#internal-type-representation">Internal type representation</a></li>
    100. 

  100. <li><a class="reference" id="advanced-types_toc" href="#advanced-types">Advanced types</a></li>
    101. 

  101. <ul class="simple"><li><a class="reference" id="advanced-types-enumerations_toc" href="#advanced-types-enumerations">Enumerations</a></li>
    102. 

  102. <li><a class="reference" id="advanced-types-ordinal-types_toc" href="#advanced-types-ordinal-types">Ordinal types</a></li>
    103. 

  103. <li><a class="reference" id="advanced-types-subranges_toc" href="#advanced-types-subranges">Subranges</a></li>
    104. 

  104. <li><a class="reference" id="advanced-types-sets_toc" href="#advanced-types-sets">Sets</a></li>
    105. 

  105. <ul class="simple"><li><a class="reference" id="sets-bit-fields_toc" href="#sets-bit-fields">Bit fields</a></li>
    106. 

  106. </ul><li><a class="reference" id="advanced-types-arrays_toc" href="#advanced-types-arrays">Arrays</a></li>
    107. 

  107. <li><a class="reference" id="advanced-types-sequences_toc" href="#advanced-types-sequences">Sequences</a></li>
    108. 

  108. <li><a class="reference" id="advanced-types-open-arrays_toc" href="#advanced-types-open-arrays">Open arrays</a></li>
    109. 

  109. <li><a class="reference" id="advanced-types-varargs_toc" href="#advanced-types-varargs">Varargs</a></li>
    110. 

  110. <li><a class="reference" id="advanced-types-slices_toc" href="#advanced-types-slices">Slices</a></li>
    111. 

  111. <li><a class="reference" id="advanced-types-objects_toc" href="#advanced-types-objects">Objects</a></li>
    112. 

  112. <li><a class="reference" id="advanced-types-tuples_toc" href="#advanced-types-tuples">Tuples</a></li>
    113. 

  113. <li><a class="reference" id="advanced-types-reference-and-pointer-types_toc" href="#advanced-types-reference-and-pointer-types">Reference and pointer types</a></li>
    114. 

  114. <li><a class="reference" id="advanced-types-procedural-type_toc" href="#advanced-types-procedural-type">Procedural type</a></li>
    115. 

  115. <li><a class="reference" id="advanced-types-distinct-type_toc" href="#advanced-types-distinct-type">Distinct type</a></li>
    116. 

  116. </ul><li><a class="reference" id="modules_toc" href="#modules">Modules</a></li>
    117. 

  117. <ul class="simple"><li><a class="reference" id="modules-excluding-symbols_toc" href="#modules-excluding-symbols">Excluding symbols</a></li>
    118. 

  118. <li><a class="reference" id="modules-from-statement_toc" href="#modules-from-statement">From statement</a></li>
    119. 

  119. <li><a class="reference" id="modules-include-statement_toc" href="#modules-include-statement">Include statement</a></li>
    120. 

  120. </ul><li><a class="reference" id="part-2_toc" href="#part-2">Part 2</a></li>
    121. 

  121. 

  122. </ul>
    123. 

  123. 

  124.   </div>
    125. 

  125.   <div class="nine columns" id="content">
    126. 

  126.     <a href="https://github.com/nim-lang/Nim/tree/devel/doc/tut1.md#L1" class="link-seesrc" target="_blank">Source</a>&nbsp;&nbsp;
    127. 

  127. <a href="https://github.com/nim-lang/Nim/edit/devel/doc/tut1.md#L1" class="link-seesrc" target="_blank" >Edit</a>&nbsp;&nbsp;
    128. 

  128. 

  129.     <div id="tocRoot"></div>
    130. 

  130.     
    131. 

  131.     <p class="module-desc"><table class="docinfo" frame="void" rules="none"><col class="docinfo-name" /><col class="docinfo-content" /><tbody valign="top"><tr><th class="docinfo-name">Author:</th><td>Andreas Rumpf</td></tr>
    132. 

  132. <tr><th class="docinfo-name">Version:</th><td>2.3.1</td></tr>
    133. 

  133. </tbody></table>
    134. 

  134. <h1><a class="toc-backref" id="introduction" href="#introduction">Introduction</a></h1><blockquote class="markdown-quote"><p>&quot;Der Mensch ist doch ein Augentier -- Schöne Dinge wünsch' ich mir.&quot;</p></blockquote>
    135. 

  135. <p>This document is a tutorial for the programming language <em>Nim</em>.</p>
    136. 

  136. <p>This tutorial assumes that you are familiar with basic programming concepts like variables, types, or statements.</p>
    137. 

  137. <p>Here are several other resources for learning Nim:</p>
    138. 

  138. <ul class="simple"><li><a class="reference external" href="https://narimiran.github.io/nim-basics/">Nim Basics tutorial</a> - a gentle introduction of the concepts mentioned above</li>
    139. 

  139. <li><a class="reference external" href="https://learnxinyminutes.com/docs/nim/">Learn Nim in 5 minutes</a> - quick, five-minute introduction to Nim</li>
    140. 

  140. <li><a class="reference external" href="manual.html">The Nim manual</a> - many more examples of the advanced language features</li>
    141. 

  141. </ul>
    142. 

  142. <p>All code examples in this tutorial, as well as the ones found in the rest of Nim's documentation, follow the <a class="reference external" href="nep1.html">Nim style guide</a>.</p>
    143. 

  143. 

  144. <h1><a class="toc-backref" id="the-first-program" href="#the-first-program">The first program</a></h1><p>We start the tour with a modified &quot;hello world&quot; program:</p>
    145. 

  145. <p><pre class="listing"><span class="Comment"># This is a comment</span>
    146. 

  146. <span class="Identifier">echo</span> <span class="StringLit">&quot;What's your name? &quot;</span>
    147. 

  147. <span class="Keyword">var</span> <span class="Identifier">name</span><span class="Punctuation">:</span> <span class="Identifier">string</span> <span class="Operator">=</span> <span class="Identifier">readLine</span><span class="Punctuation">(</span><span class="Identifier">stdin</span><span class="Punctuation">)</span>
    148. 

  148. <span class="Identifier">echo</span> <span class="StringLit">&quot;Hi, &quot;</span><span class="Punctuation">,</span> <span class="Identifier">name</span><span class="Punctuation">,</span> <span class="StringLit">&quot;!&quot;</span></pre></p>
    149. 

  149. <p>Save this code to the file &quot;greetings.nim&quot;. Now compile and run it:</p>
    150. 

  150. <p><pre class="listing"><span class="program">nim</span> <span class="option">compile</span> <span class="option">--run</span> <span class="Identifier">greetings.nim</span></pre></p>
    151. 

  151. <p>With the <tt class="docutils literal"><span class="pre">--run</span></tt> <a class="reference external" href="nimc.html#compiler-usage-commandminusline-switches">switch</a> Nim executes the file automatically after compilation. You can give your program command-line arguments by appending them after the filename:</p>
    152. 

  152. <p><pre class="listing"><span class="program">nim</span> <span class="option">compile</span> <span class="option">--run</span> <span class="Identifier">greetings.nim</span> <span class="option">arg1</span> <span class="option">arg2</span></pre></p>
    153. 

  153. <p>Commonly used commands and switches have abbreviations, so you can also use:</p>
    154. 

  154. <p><pre class="listing"><span class="program">nim</span> <span class="option">c</span> <span class="option">-r</span> <span class="Identifier">greetings.nim</span></pre></p>
    155. 

  155. <p>This is a <strong>debug version</strong>. To compile a release version use:</p>
    156. 

  156. <p><pre class="listing"><span class="program">nim</span> <span class="option">c</span> <span class="option">-d:release</span> <span class="Identifier">greetings.nim</span></pre></p>
    157. 

  157. <p>By default, the Nim compiler generates a large number of runtime checks aiming for your debugging pleasure. With <tt class="docutils literal"><span class="pre">-d:release</span></tt> some checks are <a class="reference external" href=" nimc.html#compiler-usage-compileminustime-symbols">turned off and optimizations are turned on</a>.</p>
    158. 

  158. <p>For benchmarking or production code, use the <tt class="docutils literal"><span class="pre">-d:release</span></tt> switch. For comparing the performance with unsafe languages like C, use the <tt class="docutils literal"><span class="pre">-d:danger</span></tt> switch in order to get meaningful, comparable results. Otherwise, Nim might be handicapped by checks that are <strong>not even available</strong> for C.</p>
    159. 

  159. <p>Though it should be pretty obvious what the program does, I will explain the syntax: statements which are not indented are executed when the program starts. Indentation is Nim's way of grouping statements. Indentation is done with spaces only, tabulators are not allowed.</p>
    160. 

  160. <p>String literals are enclosed in double-quotes. The <tt class="docutils literal"><span class="pre"><span class="Keyword">var</span></span></tt> statement declares a new variable named <tt class="docutils literal"><span class="pre"><span class="Identifier">name</span></span></tt> of type <tt class="docutils literal"><span class="pre"><span class="Identifier">string</span></span></tt> with the value that is returned by the <a class="reference external" href="syncio.html#readLine,File">readLine</a> procedure. Since the compiler knows that <a class="reference external" href="syncio.html#readLine,File">readLine</a> returns a string, you can leave out the type in the declaration (this is called <span id="local-type-inference_1">local type inference</span>). So this will work too:</p>
    161. 

  161. <p><pre class="listing"><span class="Keyword">var</span> <span class="Identifier">name</span> <span class="Operator">=</span> <span class="Identifier">readLine</span><span class="Punctuation">(</span><span class="Identifier">stdin</span><span class="Punctuation">)</span></pre></p>
    162. 

  162. <p>Note that this is basically the only form of type inference that exists in Nim: it is a good compromise between brevity and readability.</p>
    163. 

  163. <p>The &quot;hello world&quot; program contains several identifiers that are already known to the compiler: <tt class="docutils literal"><span class="pre"><span class="Identifier">echo</span></span></tt>, <a class="reference external" href="syncio.html#readLine,File">readLine</a>, etc. These built-ins are declared in the <a class="reference external" href="system.html">system</a> module which is implicitly imported by any other module.</p>
    164. 

  164. 

  165. <h1><a class="toc-backref" id="lexical-elements" href="#lexical-elements">Lexical elements</a></h1><p>Let us look at Nim's lexical elements in more detail: like other programming languages Nim consists of (string) literals, identifiers, keywords, comments, operators, and other punctuation marks.</p>
    166. 

  166. 

  167. <h2><a class="toc-backref" id="lexical-elements-string-and-character-literals" href="#lexical-elements-string-and-character-literals">String and character literals</a></h2><p>String literals are enclosed in double-quotes; character literals in single quotes. Special characters are escaped with <tt class="docutils literal"><span class="pre">\</span></tt>: <tt class="docutils literal"><span class="pre">\n</span></tt> means newline, <tt class="docutils literal"><span class="pre">\t</span></tt> means tabulator, etc. There are also <em>raw</em> string literals:</p>
    168. 

  168. <p><pre class="listing"><span class="RawData">r&quot;C:\program files\nim&quot;</span></pre></p>
    169. 

  169. <p>In raw literals, the backslash is not an escape character.</p>
    170. 

  170. <p>The third and last way to write string literals is <em>long-string literals</em>. They are written with three quotes: <tt class="docutils literal"><span class="pre"><span class="LongStringLit">&quot;&quot;&quot; ... &quot;&quot;&quot;</span></span></tt>; they can span over multiple lines and the <tt class="docutils literal"><span class="pre">\</span></tt> is not an escape character either. They are very useful for embedding HTML code templates for example.</p>
    171. 

  171. 

  172. <h2><a class="toc-backref" id="lexical-elements-comments" href="#lexical-elements-comments">Comments</a></h2><p>Comments start anywhere outside a string or character literal with the hash character <tt class="docutils literal"><span class="pre"><span class="Comment">#</span></span></tt>. Documentation comments start with <tt class="docutils literal"><span class="pre"><span class="Comment">##</span></span></tt>:</p>
    173. 

  173. <p><pre class="listing"><span class="Comment"># A comment.</span>
    174. 

  174. 

  175. <span class="Keyword">var</span> <span class="Identifier">myVariable</span><span class="Punctuation">:</span> <span class="Identifier">int</span> <span class="Comment">## a documentation comment</span></pre></p>
    176. 

  176. <p>Documentation comments are tokens; they are only allowed at certain places in the input file as they belong to the syntax tree! This feature enables simpler documentation generators.</p>
    177. 

  177. <p>Multiline comments are started with <tt class="docutils literal"><span class="pre"><span class="LongComment">#[</span></span></tt> and terminated with <tt class="docutils literal"><span class="pre"><span class="Punctuation">]</span><span class="Comment">#</span></span></tt>.  Multiline comments can also be nested.</p>
    178. 

  178. <p><pre class="listing"><span class="LongComment">#[
    179. 

  179. You can have any Nim code text commented
    180. 

  180. out inside this with no indentation restrictions.
    181. 

  181.       yes(&quot;May I ask a pointless question?&quot;)
    182. 

  182.   #[
    183. 

  183.      Note: these can be nested!!
    184. 

  184.   ]#
    185. 

  185. ]#</span></pre></p>
    186. 

  186. 

  187. <h2><a class="toc-backref" id="lexical-elements-numbers" href="#lexical-elements-numbers">Numbers</a></h2><p>Numerical literals are written as in most other languages. As a special twist, underscores are allowed for better readability: <tt class="docutils literal"><span class="pre"><span class="DecNumber">1_000_000</span></span></tt> (one million). A number that contains a dot (or 'e' or 'E') is a floating-point literal: <tt class="docutils literal"><span class="pre"><span class="FloatNumber">1.0e9</span></span></tt> (one billion). Hexadecimal literals are prefixed with <tt class="docutils literal"><span class="pre"><span class="HexNumber">0x</span></span></tt>, binary literals with <tt class="docutils literal"><span class="pre"><span class="BinNumber">0b</span></span></tt> and octal literals with <tt class="docutils literal"><span class="pre"><span class="OctNumber">0o</span></span></tt>. A leading zero alone does not produce an octal.</p>
    188. 

  188. 

  189. <h1><a class="toc-backref" id="the-var-statement" href="#the-var-statement">The var statement</a></h1><p>The var statement declares a new local or global variable:</p>
    190. 

  190. <p><pre class="listing"><span class="Keyword">var</span> <span class="Identifier">x</span><span class="Punctuation">,</span> <span class="Identifier">y</span><span class="Punctuation">:</span> <span class="Identifier">int</span> <span class="Comment"># declares x and y to have the type `int`</span></pre></p>
    191. 

  191. <p>Indentation can be used after the <tt class="docutils literal"><span class="pre"><span class="Keyword">var</span></span></tt> keyword to list a whole section of variables:</p>
    192. 

  192. <p><pre class="listing"><span class="Keyword">var</span>
    193. 

  193.   <span class="Identifier">x</span><span class="Punctuation">,</span> <span class="Identifier">y</span><span class="Punctuation">:</span> <span class="Identifier">int</span>
    194. 

  194.   <span class="Comment"># a comment can occur here too</span>
    195. 

  195.   <span class="Identifier">a</span><span class="Punctuation">,</span> <span class="Identifier">b</span><span class="Punctuation">,</span> <span class="Identifier">c</span><span class="Punctuation">:</span> <span class="Identifier">string</span></pre></p>
    196. 

  196. 

  197. <h1><a class="toc-backref" id="constants" href="#constants">Constants</a></h1><p>Constants are symbols which are bound to a value. The constant's value cannot change. The compiler must be able to evaluate the expression in a constant declaration at compile time:</p>
    198. 

  198. <p><pre class="listing"><span class="Keyword">const</span> <span class="Identifier">x</span> <span class="Operator">=</span> <span class="StringLit">&quot;abc&quot;</span> <span class="Comment"># the constant x contains the string &quot;abc&quot;</span></pre></p>
    199. 

  199. <p>Indentation can be used after the <tt class="docutils literal"><span class="pre"><span class="Keyword">const</span></span></tt> keyword to list a whole section of constants:</p>
    200. 

  200. <p><pre class="listing"><span class="Keyword">const</span>
    201. 

  201.   <span class="Identifier">x</span> <span class="Operator">=</span> <span class="DecNumber">1</span>
    202. 

  202.   <span class="Comment"># a comment can occur here too</span>
    203. 

  203.   <span class="Identifier">y</span> <span class="Operator">=</span> <span class="DecNumber">2</span>
    204. 

  204.   <span class="Identifier">z</span> <span class="Operator">=</span> <span class="Identifier">y</span> <span class="Operator">+</span> <span class="DecNumber">5</span> <span class="Comment"># computations are possible</span></pre></p>
    205. 

  205. 

  206. <h1><a class="toc-backref" id="the-let-statement" href="#the-let-statement">The let statement</a></h1><p>The <tt class="docutils literal"><span class="pre"><span class="Keyword">let</span></span></tt> statement works like the <tt class="docutils literal"><span class="pre"><span class="Keyword">var</span></span></tt> statement but the declared symbols are <em>single assignment</em> variables: After the initialization their value cannot change:</p>
    207. 

  207. <p><pre class="listing"><span class="Keyword">let</span> <span class="Identifier">x</span> <span class="Operator">=</span> <span class="StringLit">&quot;abc&quot;</span> <span class="Comment"># introduces a new variable `x` and binds a value to it</span>
    208. 

  208. <span class="Identifier">x</span> <span class="Operator">=</span> <span class="StringLit">&quot;xyz&quot;</span>     <span class="Comment"># Illegal: assignment to `x`</span></pre></p>
    209. 

  209. <p>The difference between <tt class="docutils literal"><span class="pre"><span class="Keyword">let</span></span></tt> and <tt class="docutils literal"><span class="pre"><span class="Keyword">const</span></span></tt> is: <tt class="docutils literal"><span class="pre"><span class="Keyword">let</span></span></tt> introduces a variable that can not be re-assigned, <tt class="docutils literal"><span class="pre"><span class="Keyword">const</span></span></tt> means &quot;enforce compile time evaluation and put it into a data section&quot;:</p>
    210. 

  210. <p><pre class="listing"><span class="Keyword">const</span> <span class="Identifier">input</span> <span class="Operator">=</span> <span class="Identifier">readLine</span><span class="Punctuation">(</span><span class="Identifier">stdin</span><span class="Punctuation">)</span> <span class="Comment"># Error: constant expression expected</span></pre></p>
    211. 

  211. <p><pre class="listing"><span class="Keyword">let</span> <span class="Identifier">input</span> <span class="Operator">=</span> <span class="Identifier">readLine</span><span class="Punctuation">(</span><span class="Identifier">stdin</span><span class="Punctuation">)</span>   <span class="Comment"># works</span></pre></p>
    212. 

  212. 

  213. <h1><a class="toc-backref" id="the-assignment-statement" href="#the-assignment-statement">The assignment statement</a></h1><p>The assignment statement assigns a new value to a variable or more generally to a storage location:</p>
    214. 

  214. <p><pre class="listing"><span class="Keyword">var</span> <span class="Identifier">x</span> <span class="Operator">=</span> <span class="StringLit">&quot;abc&quot;</span> <span class="Comment"># introduces a new variable `x` and assigns a value to it</span>
    215. 

  215. <span class="Identifier">x</span> <span class="Operator">=</span> <span class="StringLit">&quot;xyz&quot;</span>     <span class="Comment"># assigns a new value to `x`</span></pre></p>
    216. 

  216. <p><tt class="docutils literal"><span class="pre"><span class="Operator">=</span></span></tt> is the <em>assignment operator</em>. The assignment operator can be overloaded. You can declare multiple variables with a single assignment statement and all the variables will have the same value:</p>
    217. 

  217. <p><pre class="listing"><span class="Keyword">var</span> <span class="Identifier">x</span><span class="Punctuation">,</span> <span class="Identifier">y</span> <span class="Operator">=</span> <span class="DecNumber">3</span>  <span class="Comment"># assigns 3 to the variables `x` and `y`</span>
    218. 

  218. <span class="Identifier">echo</span> <span class="StringLit">&quot;x &quot;</span><span class="Punctuation">,</span> <span class="Identifier">x</span>  <span class="Comment"># outputs &quot;x 3&quot;</span>
    219. 

  219. <span class="Identifier">echo</span> <span class="StringLit">&quot;y &quot;</span><span class="Punctuation">,</span> <span class="Identifier">y</span>  <span class="Comment"># outputs &quot;y 3&quot;</span>
    220. 

  220. <span class="Identifier">x</span> <span class="Operator">=</span> <span class="DecNumber">42</span>        <span class="Comment"># changes `x` to 42 without changing `y`</span>
    221. 

  221. <span class="Identifier">echo</span> <span class="StringLit">&quot;x &quot;</span><span class="Punctuation">,</span> <span class="Identifier">x</span>  <span class="Comment"># outputs &quot;x 42&quot;</span>
    222. 

  222. <span class="Identifier">echo</span> <span class="StringLit">&quot;y &quot;</span><span class="Punctuation">,</span> <span class="Identifier">y</span>  <span class="Comment"># outputs &quot;y 3&quot;</span></pre></p>
    223. 

  223. 

  224. <h1><a class="toc-backref" id="control-flow-statements" href="#control-flow-statements">Control flow statements</a></h1><p>The greetings program consists of 3 statements that are executed sequentially. Only the most primitive programs can get away with that: branching and looping are needed too.</p>
    225. 

  225. 

  226. <h2><a class="toc-backref" id="control-flow-statements-if-statement" href="#control-flow-statements-if-statement">If statement</a></h2><p>The if statement is one way to branch the control flow:</p>
    227. 

  227. <p><pre class="listing"><span class="Keyword">let</span> <span class="Identifier">name</span> <span class="Operator">=</span> <span class="Identifier">readLine</span><span class="Punctuation">(</span><span class="Identifier">stdin</span><span class="Punctuation">)</span>
    228. 

  228. <span class="Keyword">if</span> <span class="Identifier">name</span> <span class="Operator">==</span> <span class="StringLit">&quot;&quot;</span><span class="Punctuation">:</span>
    229. 

  229.   <span class="Identifier">echo</span> <span class="StringLit">&quot;Poor soul, you lost your name?&quot;</span>
    230. 

  230. <span class="Keyword">elif</span> <span class="Identifier">name</span> <span class="Operator">==</span> <span class="StringLit">&quot;name&quot;</span><span class="Punctuation">:</span>
    231. 

  231.   <span class="Identifier">echo</span> <span class="StringLit">&quot;Very funny, your name is name.&quot;</span>
    232. 

  232. <span class="Keyword">else</span><span class="Punctuation">:</span>
    233. 

  233.   <span class="Identifier">echo</span> <span class="StringLit">&quot;Hi, &quot;</span><span class="Punctuation">,</span> <span class="Identifier">name</span><span class="Punctuation">,</span> <span class="StringLit">&quot;!&quot;</span></pre></p>
    234. 

  234. <p>There can be zero or more <tt class="docutils literal"><span class="pre"><span class="Keyword">elif</span></span></tt> parts, and the <tt class="docutils literal"><span class="pre"><span class="Keyword">else</span></span></tt> part is optional. The keyword <tt class="docutils literal"><span class="pre"><span class="Keyword">elif</span></span></tt> is short for <tt class="docutils literal"><span class="pre"><span class="Keyword">else</span> <span class="Keyword">if</span></span></tt>, and is useful to avoid excessive indentation. (The <tt class="docutils literal"><span class="pre"><span class="StringLit">&quot;&quot;</span></span></tt> is the empty string. It contains no characters.)</p>
    235. 

  235. 

  236. <h2><a class="toc-backref" id="control-flow-statements-case-statement" href="#control-flow-statements-case-statement">Case statement</a></h2><p>Another way to branch is provided by the case statement. A case statement allows for multiple branches:</p>
    237. 

  237. <p><pre class="listing"><span class="Keyword">let</span> <span class="Identifier">name</span> <span class="Operator">=</span> <span class="Identifier">readLine</span><span class="Punctuation">(</span><span class="Identifier">stdin</span><span class="Punctuation">)</span>
    238. 

  238. <span class="Keyword">case</span> <span class="Identifier">name</span>
    239. 

  239. <span class="Keyword">of</span> <span class="StringLit">&quot;&quot;</span><span class="Punctuation">:</span>
    240. 

  240.   <span class="Identifier">echo</span> <span class="StringLit">&quot;Poor soul, you lost your name?&quot;</span>
    241. 

  241. <span class="Keyword">of</span> <span class="StringLit">&quot;name&quot;</span><span class="Punctuation">:</span>
    242. 

  242.   <span class="Identifier">echo</span> <span class="StringLit">&quot;Very funny, your name is name.&quot;</span>
    243. 

  243. <span class="Keyword">of</span> <span class="StringLit">&quot;Dave&quot;</span><span class="Punctuation">,</span> <span class="StringLit">&quot;Frank&quot;</span><span class="Punctuation">:</span>
    244. 

  244.   <span class="Identifier">echo</span> <span class="StringLit">&quot;Cool name!&quot;</span>
    245. 

  245. <span class="Keyword">else</span><span class="Punctuation">:</span>
    246. 

  246.   <span class="Identifier">echo</span> <span class="StringLit">&quot;Hi, &quot;</span><span class="Punctuation">,</span> <span class="Identifier">name</span><span class="Punctuation">,</span> <span class="StringLit">&quot;!&quot;</span></pre></p>
    247. 

  247. <p>As it can be seen, for an <tt class="docutils literal"><span class="pre"><span class="Keyword">of</span></span></tt> branch a comma-separated list of values is also allowed.</p>
    248. 

  248. <p>The case statement can deal with integers, other ordinal types, and strings. (What an ordinal type is will be explained soon.) For integers or other ordinal types value ranges are also possible:</p>
    249. 

  249. <p><pre class="listing"><span class="Comment"># this statement will be explained later:</span>
    250. 

  250. <span class="Keyword">from</span> <span class="Identifier">std</span><span class="Operator">/</span><span class="Identifier">strutils</span> <span class="Keyword">import</span> <span class="Identifier">parseInt</span>
    251. 

  251. 

  252. <span class="Identifier">echo</span> <span class="StringLit">&quot;A number please: &quot;</span>
    253. 

  253. <span class="Keyword">let</span> <span class="Identifier">n</span> <span class="Operator">=</span> <span class="Identifier">parseInt</span><span class="Punctuation">(</span><span class="Identifier">readLine</span><span class="Punctuation">(</span><span class="Identifier">stdin</span><span class="Punctuation">)</span><span class="Punctuation">)</span>
    254. 

  254. <span class="Keyword">case</span> <span class="Identifier">n</span>
    255. 

  255. <span class="Keyword">of</span> <span class="FloatNumber">0.</span><span class="Operator">.</span><span class="DecNumber">2</span><span class="Punctuation">,</span> <span class="FloatNumber">4.</span><span class="Operator">.</span><span class="DecNumber">7</span><span class="Punctuation">:</span> <span class="Identifier">echo</span> <span class="StringLit">&quot;The number is in the set: {0, 1, 2, 4, 5, 6, 7}&quot;</span>
    256. 

  256. <span class="Keyword">of</span> <span class="DecNumber">3</span><span class="Punctuation">,</span> <span class="DecNumber">8</span><span class="Punctuation">:</span> <span class="Identifier">echo</span> <span class="StringLit">&quot;The number is 3 or 8&quot;</span></pre></p>
    257. 

  257. <p>However, the above code <strong>does not compile</strong>: the reason is that you have to cover every value that <tt class="docutils literal"><span class="pre"><span class="Identifier">n</span></span></tt> may contain, but the code only handles the values <tt class="docutils literal"><span class="pre"><span class="FloatNumber">0.</span><span class="Operator">.</span><span class="DecNumber">8</span></span></tt>. Since it is not very practical to list every other possible integer (though it is possible thanks to the range notation), we fix this by telling the compiler that for every other value nothing should be done:</p>
    258. 

  258. <p><pre class="listing"><span class="Operator">...</span>
    259. 

  259. <span class="Keyword">case</span> <span class="Identifier">n</span>
    260. 

  260. <span class="Keyword">of</span> <span class="FloatNumber">0.</span><span class="Operator">.</span><span class="DecNumber">2</span><span class="Punctuation">,</span> <span class="FloatNumber">4.</span><span class="Operator">.</span><span class="DecNumber">7</span><span class="Punctuation">:</span> <span class="Identifier">echo</span> <span class="StringLit">&quot;The number is in the set: {0, 1, 2, 4, 5, 6, 7}&quot;</span>
    261. 

  261. <span class="Keyword">of</span> <span class="DecNumber">3</span><span class="Punctuation">,</span> <span class="DecNumber">8</span><span class="Punctuation">:</span> <span class="Identifier">echo</span> <span class="StringLit">&quot;The number is 3 or 8&quot;</span>
    262. 

  262. <span class="Keyword">else</span><span class="Punctuation">:</span> <span class="Keyword">discard</span></pre></p>
    263. 

  263. <p>The empty <a class="reference internal" href="#procedures-discard-statement">discard statement</a> is a <em>do nothing</em> statement. The compiler knows that a case statement with an else part cannot fail and thus the error disappears. Note that it is impossible to cover all possible string values: that is why string cases always need an <tt class="docutils literal"><span class="pre"><span class="Keyword">else</span></span></tt> branch.</p>
    264. 

  264. <p>In general, the case statement is used for subrange types or enumerations where it is of great help that the compiler checks that you covered any possible value.</p>
    265. 

  265. 

  266. <h2><a class="toc-backref" id="control-flow-statements-while-statement" href="#control-flow-statements-while-statement">While statement</a></h2><p>The while statement is a simple looping construct:</p>
    267. 

  267. <p><pre class="listing"><span class="Identifier">echo</span> <span class="StringLit">&quot;What's your name? &quot;</span>
    268. 

  268. <span class="Keyword">var</span> <span class="Identifier">name</span> <span class="Operator">=</span> <span class="Identifier">readLine</span><span class="Punctuation">(</span><span class="Identifier">stdin</span><span class="Punctuation">)</span>
    269. 

  269. <span class="Keyword">while</span> <span class="Identifier">name</span> <span class="Operator">==</span> <span class="StringLit">&quot;&quot;</span><span class="Punctuation">:</span>
    270. 

  270.   <span class="Identifier">echo</span> <span class="StringLit">&quot;Please tell me your name: &quot;</span>
    271. 

  271.   <span class="Identifier">name</span> <span class="Operator">=</span> <span class="Identifier">readLine</span><span class="Punctuation">(</span><span class="Identifier">stdin</span><span class="Punctuation">)</span> <span class="Comment"># no `var`, because we do not declare a new variable here</span></pre></p>
    272. 

  272. <p>The example uses a while loop to keep asking the users for their name, as long as the user types in nothing (only presses RETURN).</p>
    273. 

  273. 

  274. <h2><a class="toc-backref" id="control-flow-statements-for-statement" href="#control-flow-statements-for-statement">For statement</a></h2><p>The <tt class="docutils literal"><span class="pre"><span class="Keyword">for</span></span></tt> statement is a construct to loop over any element an <em>iterator</em> provides. The example uses the built-in <a class="reference external" href=" system.html#countup.i,T,T,Positive">countup</a> iterator:</p>
    275. 

  275. <p><pre class="listing"><span class="Identifier">echo</span> <span class="StringLit">&quot;Counting to ten: &quot;</span>
    276. 

  276. <span class="Keyword">for</span> <span class="Identifier">i</span> <span class="Keyword">in</span> <span class="Identifier">countup</span><span class="Punctuation">(</span><span class="DecNumber">1</span><span class="Punctuation">,</span> <span class="DecNumber">10</span><span class="Punctuation">)</span><span class="Punctuation">:</span>
    277. 

  277.   <span class="Identifier">echo</span> <span class="Identifier">i</span>
    278. 

  278. <span class="Comment"># --&gt; Outputs 1 2 3 4 5 6 7 8 9 10 on different lines</span></pre></p>
    279. 

  279. <p>The variable <tt class="docutils literal"><span class="pre"><span class="Identifier">i</span></span></tt> is implicitly declared by the <tt class="docutils literal"><span class="pre"><span class="Keyword">for</span></span></tt> loop and has the type <tt class="docutils literal"><span class="pre"><span class="Identifier">int</span></span></tt>, because that is what <a class="reference external" href=" system.html#countup.i,T,T,Positive">countup</a> returns. <tt class="docutils literal"><span class="pre"><span class="Identifier">i</span></span></tt> runs through the values 1, 2, .., 10. Each value is <tt class="docutils literal"><span class="pre"><span class="Identifier">echo</span></span></tt>-ed. This code does the same:</p>
    280. 

  280. <p><pre class="listing"><span class="Identifier">echo</span> <span class="StringLit">&quot;Counting to 10: &quot;</span>
    281. 

  281. <span class="Keyword">var</span> <span class="Identifier">i</span> <span class="Operator">=</span> <span class="DecNumber">1</span>
    282. 

  282. <span class="Keyword">while</span> <span class="Identifier">i</span> <span class="Operator">&lt;=</span> <span class="DecNumber">10</span><span class="Punctuation">:</span>
    283. 

  283.   <span class="Identifier">echo</span> <span class="Identifier">i</span>
    284. 

  284.   <span class="Identifier">inc</span> <span class="Identifier">i</span> <span class="Comment"># increment i by 1</span>
    285. 

  285. <span class="Comment"># --&gt; Outputs 1 2 3 4 5 6 7 8 9 10 on different lines</span></pre></p>
    286. 

  286. <p>Since counting up occurs so often in programs, Nim also has a <a class="reference external" href=" system.html#...i,T,T">..</a> iterator that does the same:</p>
    287. 

  287. <p><pre class="listing"><span class="Keyword">for</span> <span class="Identifier">i</span> <span class="Keyword">in</span> <span class="DecNumber">1</span> <span class="Operator">..</span> <span class="DecNumber">10</span><span class="Punctuation">:</span>
    288. 

  288.   <span class="Operator">...</span></pre></p>
    289. 

  289. <p>Counting down can be achieved as easily (but is less often needed):</p>
    290. 

  290. <p><pre class="listing"><span class="Identifier">echo</span> <span class="StringLit">&quot;Counting down from 10 to 1: &quot;</span>
    291. 

  291. <span class="Keyword">for</span> <span class="Identifier">i</span> <span class="Keyword">in</span> <span class="Identifier">countdown</span><span class="Punctuation">(</span><span class="DecNumber">10</span><span class="Punctuation">,</span> <span class="DecNumber">1</span><span class="Punctuation">)</span><span class="Punctuation">:</span>
    292. 

  292.   <span class="Identifier">echo</span> <span class="Identifier">i</span>
    293. 

  293. <span class="Comment"># --&gt; Outputs 10 9 8 7 6 5 4 3 2 1 on different lines</span></pre></p>
    294. 

  294. <p>Zero-indexed counting has two shortcuts <tt class="docutils literal"><span class="pre"><span class="Operator">..&lt;</span></span></tt> and <tt class="docutils literal"><span class="pre"><span class="Operator">..</span> <span class="Operator">^</span><span class="DecNumber">1</span></span></tt> (<a class="reference external" href="system.html#^.t%2Cint">backward index operator</a>) to simplify counting to one less than the higher index:</p>
    295. 

  295. <p><pre class="listing"><span class="Keyword">for</span> <span class="Identifier">i</span> <span class="Keyword">in</span> <span class="DecNumber">0</span> <span class="Operator">..&lt;</span> <span class="DecNumber">10</span><span class="Punctuation">:</span>
    296. 

  296.   <span class="Operator">...</span>  <span class="Comment"># the same as 0 .. 9</span></pre></p>
    297. 

  297. <p>or</p>
    298. 

  298. <p><pre class="listing"><span class="Keyword">var</span> <span class="Identifier">s</span> <span class="Operator">=</span> <span class="StringLit">&quot;some string&quot;</span>
    299. 

  299. <span class="Keyword">for</span> <span class="Identifier">i</span> <span class="Keyword">in</span> <span class="DecNumber">0</span> <span class="Operator">..&lt;</span> <span class="Identifier">s</span><span class="Operator">.</span><span class="Identifier">len</span><span class="Punctuation">:</span>
    300. 

  300.   <span class="Operator">...</span></pre></p>
    301. 

  301. <p>or</p>
    302. 

  302. <p><pre class="listing"><span class="Keyword">var</span> <span class="Identifier">s</span> <span class="Operator">=</span> <span class="StringLit">&quot;some string&quot;</span>
    303. 

  303. <span class="Keyword">for</span> <span class="Identifier">idx</span><span class="Punctuation">,</span> <span class="Identifier">c</span> <span class="Keyword">in</span> <span class="Identifier">s</span><span class="Punctuation">[</span><span class="DecNumber">0</span> <span class="Operator">..</span> <span class="Operator">^</span><span class="DecNumber">1</span><span class="Punctuation">]</span><span class="Punctuation">:</span>
    304. 

  304.   <span class="Operator">...</span> <span class="Comment"># ^1 is the last element, ^2 would be one before it, and so on</span></pre></p>
    305. 

  305. <p>Other useful iterators for collections (like arrays and sequences) are</p>
    306. 

  306. <ul class="simple"><li><tt class="docutils literal"><span class="pre"><span class="Identifier">items</span></span></tt> and <tt class="docutils literal"><span class="pre"><span class="Identifier">mitems</span></span></tt>, which provides immutable and mutable elements respectively, and</li>
    307. 

  307. <li><p><tt class="docutils literal"><span class="pre"><span class="Identifier">pairs</span></span></tt> and <tt class="docutils literal"><span class="pre"><span class="Identifier">mpairs</span></span></tt> which provides the element and an index number (immutable and mutable respectively)</p>
    308. 

  308. <p><pre class="listing"><span class="Keyword">for</span> <span class="Identifier">index</span><span class="Punctuation">,</span> <span class="Identifier">item</span> <span class="Keyword">in</span> <span class="Punctuation">[</span><span class="StringLit">&quot;a&quot;</span><span class="Punctuation">,</span><span class="StringLit">&quot;b&quot;</span><span class="Punctuation">]</span><span class="Operator">.</span><span class="Identifier">pairs</span><span class="Punctuation">:</span>
    309. 

  309.   <span class="Identifier">echo</span> <span class="Identifier">item</span><span class="Punctuation">,</span> <span class="StringLit">&quot; at index &quot;</span><span class="Punctuation">,</span> <span class="Identifier">index</span>
    310. 

  310. <span class="Comment"># =&gt; a at index 0</span>
    311. 

  311. <span class="Comment"># =&gt; b at index 1</span></pre></p>
    312. 

  312. </li>
    313. 

  313. </ul>
    314. 

  314. 

  315. <h2><a class="toc-backref" id="control-flow-statements-scopes-and-the-block-statement" href="#control-flow-statements-scopes-and-the-block-statement">Scopes and the block statement</a></h2><p>Control flow statements have a feature not covered yet: they open a new scope. This means that in the following example, <tt class="docutils literal"><span class="pre"><span class="Identifier">x</span></span></tt> is not accessible outside the loop:</p>
    316. 

  316. <p><pre class="listing"><span class="Keyword">while</span> <span class="Identifier">false</span><span class="Punctuation">:</span>
    317. 

  317.   <span class="Keyword">var</span> <span class="Identifier">x</span> <span class="Operator">=</span> <span class="StringLit">&quot;hi&quot;</span>
    318. 

  318. <span class="Identifier">echo</span> <span class="Identifier">x</span> <span class="Comment"># does not work</span></pre></p>
    319. 

  319. <p>A while (for) statement introduces an implicit block. Identifiers are only visible within the block they have been declared. The <tt class="docutils literal"><span class="pre"><span class="Keyword">block</span></span></tt> statement can be used to open a new block explicitly:</p>
    320. 

  320. <p><pre class="listing"><span class="Keyword">block</span> <span class="Identifier">myblock</span><span class="Punctuation">:</span>
    321. 

  321.   <span class="Keyword">var</span> <span class="Identifier">x</span> <span class="Operator">=</span> <span class="StringLit">&quot;hi&quot;</span>
    322. 

  322. <span class="Identifier">echo</span> <span class="Identifier">x</span> <span class="Comment"># does not work either</span></pre></p>
    323. 

  323. <p>The block's <em>label</em> (<tt class="docutils literal"><span class="pre"><span class="Identifier">myblock</span></span></tt> in the example) is optional.</p>
    324. 

  324. 

  325. <h2><a class="toc-backref" id="control-flow-statements-break-statement" href="#control-flow-statements-break-statement">Break statement</a></h2><p>A block can be left prematurely with a <tt class="docutils literal"><span class="pre"><span class="Keyword">break</span></span></tt> statement. The break statement can leave a <tt class="docutils literal"><span class="pre"><span class="Keyword">while</span></span></tt>, <tt class="docutils literal"><span class="pre"><span class="Keyword">for</span></span></tt>, or a <tt class="docutils literal"><span class="pre"><span class="Keyword">block</span></span></tt> statement. It leaves the innermost construct, unless a label of a block is given:</p>
    326. 

  326. <p><pre class="listing"><span class="Keyword">block</span> <span class="Identifier">myblock</span><span class="Punctuation">:</span>
    327. 

  327.   <span class="Identifier">echo</span> <span class="StringLit">&quot;entering block&quot;</span>
    328. 

  328.   <span class="Keyword">while</span> <span class="Identifier">true</span><span class="Punctuation">:</span>
    329. 

  329.     <span class="Identifier">echo</span> <span class="StringLit">&quot;looping&quot;</span>
    330. 

  330.     <span class="Keyword">break</span> <span class="Comment"># leaves the loop, but not the block</span>
    331. 

  331.   <span class="Identifier">echo</span> <span class="StringLit">&quot;still in block&quot;</span>
    332. 

  332. <span class="Identifier">echo</span> <span class="StringLit">&quot;outside the block&quot;</span>
    333. 

  333. 

  334. <span class="Keyword">block</span> <span class="Identifier">myblock2</span><span class="Punctuation">:</span>
    335. 

  335.   <span class="Identifier">echo</span> <span class="StringLit">&quot;entering block&quot;</span>
    336. 

  336.   <span class="Keyword">while</span> <span class="Identifier">true</span><span class="Punctuation">:</span>
    337. 

  337.     <span class="Identifier">echo</span> <span class="StringLit">&quot;looping&quot;</span>
    338. 

  338.     <span class="Keyword">break</span> <span class="Identifier">myblock2</span> <span class="Comment"># leaves the block (and the loop)</span>
    339. 

  339.   <span class="Identifier">echo</span> <span class="StringLit">&quot;still in block&quot;</span> <span class="Comment"># it won't be printed</span>
    340. 

  340. <span class="Identifier">echo</span> <span class="StringLit">&quot;outside the block&quot;</span></pre></p>
    341. 

  341. 

  342. <h2><a class="toc-backref" id="control-flow-statements-continue-statement" href="#control-flow-statements-continue-statement">Continue statement</a></h2><p>Like in many other programming languages, a <tt class="docutils literal"><span class="pre"><span class="Keyword">continue</span></span></tt> statement starts the next iteration immediately:</p>
    343. 

  343. <p><pre class="listing"><span class="Keyword">for</span> <span class="Identifier">i</span> <span class="Keyword">in</span> <span class="DecNumber">1</span> <span class="Operator">..</span> <span class="DecNumber">5</span><span class="Punctuation">:</span>
    344. 

  344.   <span class="Keyword">if</span> <span class="Identifier">i</span> <span class="Operator">&lt;=</span> <span class="DecNumber">3</span><span class="Punctuation">:</span> <span class="Keyword">continue</span>
    345. 

  345.   <span class="Identifier">echo</span> <span class="Identifier">i</span> <span class="Comment"># will only print 4 and 5</span></pre></p>
    346. 

  346. 

  347. <h2><a class="toc-backref" id="control-flow-statements-when-statement" href="#control-flow-statements-when-statement">When statement</a></h2><p>Example:</p>
    348. 

  348. <p><pre class="listing"><span class="Keyword">when</span> <span class="Identifier">system</span><span class="Operator">.</span><span class="Identifier">hostOS</span> <span class="Operator">==</span> <span class="StringLit">&quot;windows&quot;</span><span class="Punctuation">:</span>
    349. 

  349.   <span class="Identifier">echo</span> <span class="StringLit">&quot;running on Windows!&quot;</span>
    350. 

  350. <span class="Keyword">elif</span> <span class="Identifier">system</span><span class="Operator">.</span><span class="Identifier">hostOS</span> <span class="Operator">==</span> <span class="StringLit">&quot;linux&quot;</span><span class="Punctuation">:</span>
    351. 

  351.   <span class="Identifier">echo</span> <span class="StringLit">&quot;running on Linux!&quot;</span>
    352. 

  352. <span class="Keyword">elif</span> <span class="Identifier">system</span><span class="Operator">.</span><span class="Identifier">hostOS</span> <span class="Operator">==</span> <span class="StringLit">&quot;macosx&quot;</span><span class="Punctuation">:</span>
    353. 

  353.   <span class="Identifier">echo</span> <span class="StringLit">&quot;running on Mac OS X!&quot;</span>
    354. 

  354. <span class="Keyword">else</span><span class="Punctuation">:</span>
    355. 

  355.   <span class="Identifier">echo</span> <span class="StringLit">&quot;unknown operating system&quot;</span></pre></p>
    356. 

  356. <p>The <tt class="docutils literal"><span class="pre"><span class="Keyword">when</span></span></tt> statement is almost identical to the <tt class="docutils literal"><span class="pre"><span class="Keyword">if</span></span></tt> statement, but with these differences:</p>
    357. 

  357. <ul class="simple"><li>Each condition must be a constant expression since it is evaluated by the compiler.</li>
    358. 

  358. <li>The statements within a branch do not open a new scope.</li>
    359. 

  359. <li>The compiler checks the semantics and produces code <em>only</em> for the statements that belong to the first condition that evaluates to <tt class="docutils literal"><span class="pre"><span class="Identifier">true</span></span></tt>.</li>
    360. 

  360. </ul>
    361. 

  361. <p>The <tt class="docutils literal"><span class="pre"><span class="Keyword">when</span></span></tt> statement is useful for writing platform-specific code, similar to the <tt class="docutils literal"><span class="pre"><span class="Preprocessor">#ifdef</span></span></tt> construct in the C programming language.</p>
    362. 

  362. 

  363. <h1><a class="toc-backref" id="statements-and-indentation" href="#statements-and-indentation">Statements and indentation</a></h1><p>Now that we covered the basic control flow statements, let's return to Nim indentation rules.</p>
    364. 

  364. <p>In Nim, there is a distinction between <em>simple statements</em> and <em>complex statements</em>. <em>Simple statements</em> cannot contain other statements: Assignment, procedure calls, or the <tt class="docutils literal"><span class="pre"><span class="Keyword">return</span></span></tt> statement are all simple statements. <em>Complex statements</em> like <tt class="docutils literal"><span class="pre"><span class="Keyword">if</span></span></tt>, <tt class="docutils literal"><span class="pre"><span class="Keyword">when</span></span></tt>, <tt class="docutils literal"><span class="pre"><span class="Keyword">for</span></span></tt>, <tt class="docutils literal"><span class="pre"><span class="Keyword">while</span></span></tt> can contain other statements. To avoid ambiguities, complex statements must always be indented, but single simple statements do not:</p>
    365. 

  365. <p><pre class="listing"><span class="Comment"># no indentation needed for single-assignment statement:</span>
    366. 

  366. <span class="Keyword">if</span> <span class="Identifier">x</span><span class="Punctuation">:</span> <span class="Identifier">x</span> <span class="Operator">=</span> <span class="Identifier">false</span>
    367. 

  367. 

  368. <span class="Comment"># indentation needed for nested if statement:</span>
    369. 

  369. <span class="Keyword">if</span> <span class="Identifier">x</span><span class="Punctuation">:</span>
    370. 

  370.   <span class="Keyword">if</span> <span class="Identifier">y</span><span class="Punctuation">:</span>
    371. 

  371.     <span class="Identifier">y</span> <span class="Operator">=</span> <span class="Identifier">false</span>
    372. 

  372.   <span class="Keyword">else</span><span class="Punctuation">:</span>
    373. 

  373.     <span class="Identifier">y</span> <span class="Operator">=</span> <span class="Identifier">true</span>
    374. 

  374. 

  375. <span class="Comment"># indentation needed, because two statements follow the condition:</span>
    376. 

  376. <span class="Keyword">if</span> <span class="Identifier">x</span><span class="Punctuation">:</span>
    377. 

  377.   <span class="Identifier">x</span> <span class="Operator">=</span> <span class="Identifier">false</span>
    378. 

  378.   <span class="Identifier">y</span> <span class="Operator">=</span> <span class="Identifier">false</span></pre></p>
    379. 

  379. <p><em>Expressions</em> are parts of a statement that usually result in a value. The condition in an if statement is an example of an expression. Expressions can contain indentation at certain places for better readability:</p>
    380. 

  380. <p><pre class="listing"><span class="Keyword">if</span> <span class="Identifier">thisIsaLongCondition</span><span class="Punctuation">(</span><span class="Punctuation">)</span> <span class="Keyword">and</span>
    381. 

  381.     <span class="Identifier">thisIsAnotherLongCondition</span><span class="Punctuation">(</span><span class="DecNumber">1</span><span class="Punctuation">,</span>
    382. 

  382.        <span class="DecNumber">2</span><span class="Punctuation">,</span> <span class="DecNumber">3</span><span class="Punctuation">,</span> <span class="DecNumber">4</span><span class="Punctuation">)</span><span class="Punctuation">:</span>
    383. 

  383.   <span class="Identifier">x</span> <span class="Operator">=</span> <span class="Identifier">true</span></pre></p>
    384. 

  384. <p>As a rule of thumb, indentation within expressions is allowed after operators, an open parenthesis and after commas.</p>
    385. 

  385. <p>With parenthesis and semicolons <tt class="docutils literal"><span class="pre"><span class="Punctuation">(</span><span class="Punctuation">;</span><span class="Punctuation">)</span></span></tt> you can use statements where only an expression is allowed:</p>
    386. 

  386. <p><pre class="listing"><span class="Comment"># computes fac(4) at compile time:</span>
    387. 

  387. <span class="Keyword">const</span> <span class="Identifier">fac4</span> <span class="Operator">=</span> <span class="Punctuation">(</span><span class="Keyword">var</span> <span class="Identifier">x</span> <span class="Operator">=</span> <span class="DecNumber">1</span><span class="Punctuation">;</span> <span class="Keyword">for</span> <span class="Identifier">i</span> <span class="Keyword">in</span> <span class="FloatNumber">1.</span><span class="Operator">.</span><span class="DecNumber">4</span><span class="Punctuation">:</span> <span class="Identifier">x</span> <span class="Operator">*=</span> <span class="Identifier">i</span><span class="Punctuation">;</span> <span class="Identifier">x</span><span class="Punctuation">)</span></pre></p>
    388. 

  388. 

  389. <h1><a class="toc-backref" id="procedures" href="#procedures">Procedures</a></h1><p>To define new commands like <a class="reference external" href="system.html#echo,varargs[typed,]">echo</a> and <a class="reference external" href="syncio.html#readLine,File">readLine</a> in the examples, the concept of a <em>procedure</em> is needed. You might be used to them being called <em>methods</em> or <em>functions</em> in other languages, but Nim <a class="reference external" href="tut1.html#procedures-funcs-and-methods">differentiates these concepts</a>. In Nim, new procedures are defined with the <tt class="docutils literal"><span class="pre"><span class="Keyword">proc</span></span></tt> keyword:</p>
    390. 

  390. <p><pre class="listing"><span class="Keyword">proc</span> <span class="Identifier">yes</span><span class="Punctuation">(</span><span class="Identifier">question</span><span class="Punctuation">:</span> <span class="Identifier">string</span><span class="Punctuation">)</span><span class="Punctuation">:</span> <span class="Identifier">bool</span> <span class="Operator">=</span>
    391. 

  391.   <span class="Identifier">echo</span> <span class="Identifier">question</span><span class="Punctuation">,</span> <span class="StringLit">&quot; (y/n)&quot;</span>
    392. 

  392.   <span class="Keyword">while</span> <span class="Identifier">true</span><span class="Punctuation">:</span>
    393. 

  393.     <span class="Keyword">case</span> <span class="Identifier">readLine</span><span class="Punctuation">(</span><span class="Identifier">stdin</span><span class="Punctuation">)</span>
    394. 

  394.     <span class="Keyword">of</span> <span class="StringLit">&quot;y&quot;</span><span class="Punctuation">,</span> <span class="StringLit">&quot;Y&quot;</span><span class="Punctuation">,</span> <span class="StringLit">&quot;yes&quot;</span><span class="Punctuation">,</span> <span class="StringLit">&quot;Yes&quot;</span><span class="Punctuation">:</span> <span class="Keyword">return</span> <span class="Identifier">true</span>
    395. 

  395.     <span class="Keyword">of</span> <span class="StringLit">&quot;n&quot;</span><span class="Punctuation">,</span> <span class="StringLit">&quot;N&quot;</span><span class="Punctuation">,</span> <span class="StringLit">&quot;no&quot;</span><span class="Punctuation">,</span> <span class="StringLit">&quot;No&quot;</span><span class="Punctuation">:</span> <span class="Keyword">return</span> <span class="Identifier">false</span>
    396. 

  396.     <span class="Keyword">else</span><span class="Punctuation">:</span> <span class="Identifier">echo</span> <span class="StringLit">&quot;Please be clear: yes or no&quot;</span>
    397. 

  397. 

  398. <span class="Keyword">if</span> <span class="Identifier">yes</span><span class="Punctuation">(</span><span class="StringLit">&quot;Should I delete all your important files?&quot;</span><span class="Punctuation">)</span><span class="Punctuation">:</span>
    399. 

  399.   <span class="Identifier">echo</span> <span class="StringLit">&quot;I'm sorry Dave, I'm afraid I can't do that.&quot;</span>
    400. 

  400. <span class="Keyword">else</span><span class="Punctuation">:</span>
    401. 

  401.   <span class="Identifier">echo</span> <span class="StringLit">&quot;I think you know what the problem is just as well as I do.&quot;</span></pre></p>
    402. 

  402. <p>This example shows a procedure named <tt class="docutils literal"><span class="pre"><span class="Identifier">yes</span></span></tt> that asks the user a <tt class="docutils literal"><span class="pre"><span class="Identifier">question</span></span></tt> and returns true if they answered &quot;yes&quot; (or something similar) and returns false if they answered &quot;no&quot; (or something similar). A <tt class="docutils literal"><span class="pre"><span class="Keyword">return</span></span></tt> statement leaves the procedure (and therefore the while loop) immediately. The <tt class="docutils literal"><span class="pre"><span class="Punctuation">(</span><span class="Identifier">question</span><span class="Punctuation">:</span> <span class="Identifier">string</span><span class="Punctuation">)</span><span class="Punctuation">:</span> <span class="Identifier">bool</span></span></tt> syntax describes that the procedure expects a parameter named <tt class="docutils literal"><span class="pre"><span class="Identifier">question</span></span></tt> of type <tt class="docutils literal"><span class="pre"><span class="Identifier">string</span></span></tt> and returns a value of type <tt class="docutils literal"><span class="pre"><span class="Identifier">bool</span></span></tt>. The <tt class="docutils literal"><span class="pre"><span class="Identifier">bool</span></span></tt> type is built-in: the only valid values for <tt class="docutils literal"><span class="pre"><span class="Identifier">bool</span></span></tt> are <tt class="docutils literal"><span class="pre"><span class="Identifier">true</span></span></tt> and <tt class="docutils literal"><span class="pre"><span class="Identifier">false</span></span></tt>. The conditions in if or while statements must be of type <tt class="docutils literal"><span class="pre"><span class="Identifier">bool</span></span></tt>.</p>
    403. 

  403. <p>Some terminology: in the example <tt class="docutils literal"><span class="pre"><span class="Identifier">question</span></span></tt> is called a (formal) <em>parameter</em>, <tt class="docutils literal"><span class="pre"><span class="StringLit">&quot;Should I...&quot;</span></span></tt> is called an <em>argument</em> that is passed to this parameter.</p>
    404. 

  404. 

  405. <h2><a class="toc-backref" id="procedures-result-variable" href="#procedures-result-variable">Result variable</a></h2><p>A procedure that returns a value has an implicit <tt class="docutils literal"><span class="pre"><span class="Identifier">result</span></span></tt> variable declared that represents the return value. A <tt class="docutils literal"><span class="pre"><span class="Keyword">return</span></span></tt> statement with no expression is shorthand for <tt class="docutils literal"><span class="pre"><span class="Keyword">return</span> <span class="Identifier">result</span></span></tt>. The <tt class="docutils literal"><span class="pre"><span class="Identifier">result</span></span></tt> value is always returned automatically at the end of a procedure if there is no <tt class="docutils literal"><span class="pre"><span class="Keyword">return</span></span></tt> statement at the exit.</p>
    406. 

  406. <p><pre class="listing"><span class="Keyword">proc</span> <span class="Identifier">sumTillNegative</span><span class="Punctuation">(</span><span class="Identifier">x</span><span class="Punctuation">:</span> <span class="Identifier">varargs</span><span class="Punctuation">[</span><span class="Identifier">int</span><span class="Punctuation">]</span><span class="Punctuation">)</span><span class="Punctuation">:</span> <span class="Identifier">int</span> <span class="Operator">=</span>
    407. 

  407.   <span class="Keyword">for</span> <span class="Identifier">i</span> <span class="Keyword">in</span> <span class="Identifier">x</span><span class="Punctuation">:</span>
    408. 

  408.     <span class="Keyword">if</span> <span class="Identifier">i</span> <span class="Operator">&lt;</span> <span class="DecNumber">0</span><span class="Punctuation">:</span>
    409. 

  409.       <span class="Keyword">return</span>
    410. 

  410.     <span class="Identifier">result</span> <span class="Operator">=</span> <span class="Identifier">result</span> <span class="Operator">+</span> <span class="Identifier">i</span>
    411. 

  411. 

  412. <span class="Identifier">echo</span> <span class="Identifier">sumTillNegative</span><span class="Punctuation">(</span><span class="Punctuation">)</span> <span class="Comment"># echoes 0</span>
    413. 

  413. <span class="Identifier">echo</span> <span class="Identifier">sumTillNegative</span><span class="Punctuation">(</span><span class="DecNumber">3</span><span class="Punctuation">,</span> <span class="DecNumber">4</span><span class="Punctuation">,</span> <span class="DecNumber">5</span><span class="Punctuation">)</span> <span class="Comment"># echoes 12</span>
    414. 

  414. <span class="Identifier">echo</span> <span class="Identifier">sumTillNegative</span><span class="Punctuation">(</span><span class="DecNumber">3</span><span class="Punctuation">,</span> <span class="DecNumber">4</span> <span class="Punctuation">,</span> <span class="Operator">-</span><span class="DecNumber">1</span> <span class="Punctuation">,</span> <span class="DecNumber">6</span><span class="Punctuation">)</span> <span class="Comment"># echoes 7</span></pre></p>
    415. 

  415. <p>The <tt class="docutils literal"><span class="pre"><span class="Identifier">result</span></span></tt> variable is already implicitly declared at the start of the function, so declaring it again with 'var result', for example, would shadow it with a normal variable of the same name. The result variable is also already initialized with the type's default value. Note that referential data types will be <tt class="docutils literal"><span class="pre"><span class="Keyword">nil</span></span></tt> at the start of the procedure, and thus may require manual initialization.</p>
    416. 

  416. <p>A procedure that does not have any <tt class="docutils literal"><span class="pre"><span class="Keyword">return</span></span></tt> statement and does not use the special <tt class="docutils literal"><span class="pre"><span class="Identifier">result</span></span></tt> variable returns the value of its last expression. For example, this procedure</p>
    417. 

  417. <p><pre class="listing"><span class="Keyword">proc</span> <span class="Identifier">helloWorld</span><span class="Punctuation">(</span><span class="Punctuation">)</span><span class="Punctuation">:</span> <span class="Identifier">string</span> <span class="Operator">=</span>
    418. 

  418.   <span class="StringLit">&quot;Hello, World!&quot;</span></pre></p>
    419. 

  419. <p>returns the string &quot;Hello, World!&quot;.</p>
    420. 

  420. 

  421. <h2><a class="toc-backref" id="procedures-parameters" href="#procedures-parameters">Parameters</a></h2><p>Parameters are immutable in the procedure body. By default, their value cannot be changed because this allows the compiler to implement parameter passing in the most efficient way. If a mutable variable is needed inside the procedure, it has to be declared with <tt class="docutils literal"><span class="pre"><span class="Keyword">var</span></span></tt> in the procedure body. Shadowing the parameter name is possible, and actually an idiom:</p>
    422. 

  422. <p><pre class="listing"><span class="Keyword">proc</span> <span class="Identifier">printSeq</span><span class="Punctuation">(</span><span class="Identifier">s</span><span class="Punctuation">:</span> <span class="Identifier">seq</span><span class="Punctuation">,</span> <span class="Identifier">nprinted</span><span class="Punctuation">:</span> <span class="Identifier">int</span> <span class="Operator">=</span> <span class="Operator">-</span><span class="DecNumber">1</span><span class="Punctuation">)</span> <span class="Operator">=</span>
    423. 

  423.   <span class="Keyword">var</span> <span class="Identifier">nprinted</span> <span class="Operator">=</span> <span class="Keyword">if</span> <span class="Identifier">nprinted</span> <span class="Operator">==</span> <span class="Operator">-</span><span class="DecNumber">1</span><span class="Punctuation">:</span> <span class="Identifier">s</span><span class="Operator">.</span><span class="Identifier">len</span> <span class="Keyword">else</span><span class="Punctuation">:</span> <span class="Identifier">min</span><span class="Punctuation">(</span><span class="Identifier">nprinted</span><span class="Punctuation">,</span> <span class="Identifier">s</span><span class="Operator">.</span><span class="Identifier">len</span><span class="Punctuation">)</span>
    424. 

  424.   <span class="Keyword">for</span> <span class="Identifier">i</span> <span class="Keyword">in</span> <span class="DecNumber">0</span> <span class="Operator">..&lt;</span> <span class="Identifier">nprinted</span><span class="Punctuation">:</span>
    425. 

  425.     <span class="Identifier">echo</span> <span class="Identifier">s</span><span class="Punctuation">[</span><span class="Identifier">i</span><span class="Punctuation">]</span></pre></p>
    426. 

  426. <p>If the procedure needs to modify the argument for the caller, a <tt class="docutils literal"><span class="pre"><span class="Keyword">var</span></span></tt> parameter can be used:</p>
    427. 

  427. <p><pre class="listing"><span class="Keyword">proc</span> <span class="Identifier">divmod</span><span class="Punctuation">(</span><span class="Identifier">a</span><span class="Punctuation">,</span> <span class="Identifier">b</span><span class="Punctuation">:</span> <span class="Identifier">int</span><span class="Punctuation">;</span> <span class="Identifier">res</span><span class="Punctuation">,</span> <span class="Identifier">remainder</span><span class="Punctuation">:</span> <span class="Keyword">var</span> <span class="Identifier">int</span><span class="Punctuation">)</span> <span class="Operator">=</span>
    428. 

  428.   <span class="Identifier">res</span> <span class="Operator">=</span> <span class="Identifier">a</span> <span class="Keyword">div</span> <span class="Identifier">b</span>        <span class="Comment"># integer division</span>
    429. 

  429.   <span class="Identifier">remainder</span> <span class="Operator">=</span> <span class="Identifier">a</span> <span class="Keyword">mod</span> <span class="Identifier">b</span>  <span class="Comment"># integer modulo operation</span>
    430. 

  430. 

  431. <span class="Keyword">var</span>
    432. 

  432.   <span class="Identifier">x</span><span class="Punctuation">,</span> <span class="Identifier">y</span><span class="Punctuation">:</span> <span class="Identifier">int</span>
    433. 

  433. <span class="Identifier">divmod</span><span class="Punctuation">(</span><span class="DecNumber">8</span><span class="Punctuation">,</span> <span class="DecNumber">5</span><span class="Punctuation">,</span> <span class="Identifier">x</span><span class="Punctuation">,</span> <span class="Identifier">y</span><span class="Punctuation">)</span> <span class="Comment"># modifies x and y</span>
    434. 

  434. <span class="Identifier">echo</span> <span class="Identifier">x</span>
    435. 

  435. <span class="Identifier">echo</span> <span class="Identifier">y</span></pre></p>
    436. 

  436. <p>In the example, <tt class="docutils literal"><span class="pre"><span class="Identifier">res</span></span></tt> and <tt class="docutils literal"><span class="pre"><span class="Identifier">remainder</span></span></tt> are <tt class="docutils literal"><span class="pre"><span class="Keyword">var</span> <span class="Identifier">parameters</span></span></tt>. Var parameters can be modified by the procedure and the changes are visible to the caller. Note that the above example would better make use of a tuple as a return value instead of using var parameters.</p>
    437. 

  437. 

  438. <h2><a class="toc-backref" id="procedures-discard-statement" href="#procedures-discard-statement">Discard statement</a></h2><p>To call a procedure that returns a value just for its side effects and ignoring its return value, a <tt class="docutils literal"><span class="pre"><span class="Keyword">discard</span></span></tt> statement <strong>must</strong> be used. Nim does not allow silently throwing away a return value:</p>
    439. 

  439. <p><pre class="listing"><span class="Keyword">discard</span> <span class="Identifier">yes</span><span class="Punctuation">(</span><span class="StringLit">&quot;May I ask a pointless question?&quot;</span><span class="Punctuation">)</span></pre></p>
    440. 

  440. <p>The return value can be ignored implicitly if the called proc/iterator has been declared with the <tt class="docutils literal"><span class="pre"><span class="Identifier">discardable</span></span></tt> pragma:</p>
    441. 

  441. <p><pre class="listing"><span class="Keyword">proc</span> <span class="Identifier">p</span><span class="Punctuation">(</span><span class="Identifier">x</span><span class="Punctuation">,</span> <span class="Identifier">y</span><span class="Punctuation">:</span> <span class="Identifier">int</span><span class="Punctuation">)</span><span class="Punctuation">:</span> <span class="Identifier">int</span> <span class="Punctuation">{</span><span class="Operator">.</span><span class="Identifier">discardable</span><span class="Operator">.</span><span class="Punctuation">}</span> <span class="Operator">=</span>
    442. 

  442.   <span class="Keyword">return</span> <span class="Identifier">x</span> <span class="Operator">+</span> <span class="Identifier">y</span>
    443. 

  443. 

  444. <span class="Identifier">p</span><span class="Punctuation">(</span><span class="DecNumber">3</span><span class="Punctuation">,</span> <span class="DecNumber">4</span><span class="Punctuation">)</span> <span class="Comment"># now valid</span></pre></p>
    445. 

  445. 

  446. <h2><a class="toc-backref" id="procedures-named-arguments" href="#procedures-named-arguments">Named arguments</a></h2><p>Often a procedure has many parameters and it is not clear in which order the parameters appear. This is especially true for procedures that construct a complex data type. Therefore, the arguments to a procedure can be named, so that it is clear which argument belongs to which parameter:</p>
    447. 

  447. <p><pre class="listing"><span class="Keyword">proc</span> <span class="Identifier">createWindow</span><span class="Punctuation">(</span><span class="Identifier">x</span><span class="Punctuation">,</span> <span class="Identifier">y</span><span class="Punctuation">,</span> <span class="Identifier">width</span><span class="Punctuation">,</span> <span class="Identifier">height</span><span class="Punctuation">:</span> <span class="Identifier">int</span><span class="Punctuation">;</span> <span class="Identifier">title</span><span class="Punctuation">:</span> <span class="Identifier">string</span><span class="Punctuation">;</span>
    448. 

  448.                   <span class="Identifier">show</span><span class="Punctuation">:</span> <span class="Identifier">bool</span><span class="Punctuation">)</span><span class="Punctuation">:</span> <span class="Identifier">Window</span> <span class="Operator">=</span>
    449. 

  449.    <span class="Operator">...</span>
    450. 

  450. 

  451. <span class="Keyword">var</span> <span class="Identifier">w</span> <span class="Operator">=</span> <span class="Identifier">createWindow</span><span class="Punctuation">(</span><span class="Identifier">show</span> <span class="Operator">=</span> <span class="Identifier">true</span><span class="Punctuation">,</span> <span class="Identifier">title</span> <span class="Operator">=</span> <span class="StringLit">&quot;My Application&quot;</span><span class="Punctuation">,</span>
    452. 

  452.                      <span class="Identifier">x</span> <span class="Operator">=</span> <span class="DecNumber">0</span><span class="Punctuation">,</span> <span class="Identifier">y</span> <span class="Operator">=</span> <span class="DecNumber">0</span><span class="Punctuation">,</span> <span class="Identifier">height</span> <span class="Operator">=</span> <span class="DecNumber">600</span><span class="Punctuation">,</span> <span class="Identifier">width</span> <span class="Operator">=</span> <span class="DecNumber">800</span><span class="Punctuation">)</span></pre></p>
    453. 

  453. <p>Now that we use named arguments to call <tt class="docutils literal"><span class="pre"><span class="Identifier">createWindow</span></span></tt> the argument order does not matter anymore. Mixing named arguments with ordered arguments is also possible, but not very readable:</p>
    454. 

  454. <p><pre class="listing"><span class="Keyword">var</span> <span class="Identifier">w</span> <span class="Operator">=</span> <span class="Identifier">createWindow</span><span class="Punctuation">(</span><span class="DecNumber">0</span><span class="Punctuation">,</span> <span class="DecNumber">0</span><span class="Punctuation">,</span> <span class="Identifier">title</span> <span class="Operator">=</span> <span class="StringLit">&quot;My Application&quot;</span><span class="Punctuation">,</span>
    455. 

  455.                      <span class="Identifier">height</span> <span class="Operator">=</span> <span class="DecNumber">600</span><span class="Punctuation">,</span> <span class="Identifier">width</span> <span class="Operator">=</span> <span class="DecNumber">800</span><span class="Punctuation">,</span> <span class="Identifier">true</span><span class="Punctuation">)</span></pre></p>
    456. 

  456. <p>The compiler checks that each parameter receives exactly one argument.</p>
    457. 

  457. 

  458. <h2><a class="toc-backref" id="procedures-default-values" href="#procedures-default-values">Default values</a></h2><p>To make the <tt class="docutils literal"><span class="pre"><span class="Identifier">createWindow</span></span></tt> proc easier to use it should provide <tt class="docutils literal"><span class="pre"><span class="Identifier">default</span> <span class="Identifier">values</span></span></tt>; these are values that are used as arguments if the caller does not specify them:</p>
    459. 

  459. <p><pre class="listing"><span class="Keyword">proc</span> <span class="Identifier">createWindow</span><span class="Punctuation">(</span><span class="Identifier">x</span> <span class="Operator">=</span> <span class="DecNumber">0</span><span class="Punctuation">,</span> <span class="Identifier">y</span> <span class="Operator">=</span> <span class="DecNumber">0</span><span class="Punctuation">,</span> <span class="Identifier">width</span> <span class="Operator">=</span> <span class="DecNumber">500</span><span class="Punctuation">,</span> <span class="Identifier">height</span> <span class="Operator">=</span> <span class="DecNumber">700</span><span class="Punctuation">,</span>
    460. 

  460.                   <span class="Identifier">title</span> <span class="Operator">=</span> <span class="StringLit">&quot;unknown&quot;</span><span class="Punctuation">,</span>
    461. 

  461.                   <span class="Identifier">show</span> <span class="Operator">=</span> <span class="Identifier">true</span><span class="Punctuation">)</span><span class="Punctuation">:</span> <span class="Identifier">Window</span> <span class="Operator">=</span>
    462. 

  462.    <span class="Operator">...</span>
    463. 

  463. 

  464. <span class="Keyword">var</span> <span class="Identifier">w</span> <span class="Operator">=</span> <span class="Identifier">createWindow</span><span class="Punctuation">(</span><span class="Identifier">title</span> <span class="Operator">=</span> <span class="StringLit">&quot;My Application&quot;</span><span class="Punctuation">,</span> <span class="Identifier">height</span> <span class="Operator">=</span> <span class="DecNumber">600</span><span class="Punctuation">,</span> <span class="Identifier">width</span> <span class="Operator">=</span> <span class="DecNumber">800</span><span class="Punctuation">)</span></pre></p>
    465. 

  465. <p>Now the call to <tt class="docutils literal"><span class="pre"><span class="Identifier">createWindow</span></span></tt> only needs to set the values that differ from the defaults.</p>
    466. 

  466. <p>Note that type inference works for parameters with default values; there is no need to write <tt class="docutils literal"><span class="pre"><span class="Identifier">title</span><span class="Punctuation">:</span> <span class="Identifier">string</span> <span class="Operator">=</span> <span class="StringLit">&quot;unknown&quot;</span></span></tt>, for example.</p>
    467. 

  467. 

  468. <h2><a class="toc-backref" id="procedures-overloaded-procedures" href="#procedures-overloaded-procedures">Overloaded procedures</a></h2><p>Nim provides the ability to overload procedures similar to C++:</p>
    469. 

  469. <p><pre class="listing"><span class="Keyword">proc</span> <span class="Identifier">toString</span><span class="Punctuation">(</span><span class="Identifier">x</span><span class="Punctuation">:</span> <span class="Identifier">int</span><span class="Punctuation">)</span><span class="Punctuation">:</span> <span class="Identifier">string</span> <span class="Operator">=</span>
    470. 

  470.   <span class="Identifier">result</span> <span class="Operator">=</span>
    471. 

  471.     <span class="Keyword">if</span> <span class="Identifier">x</span> <span class="Operator">&lt;</span> <span class="DecNumber">0</span><span class="Punctuation">:</span> <span class="StringLit">&quot;negative&quot;</span>
    472. 

  472.     <span class="Keyword">elif</span> <span class="Identifier">x</span> <span class="Operator">&gt;</span> <span class="DecNumber">0</span><span class="Punctuation">:</span> <span class="StringLit">&quot;positive&quot;</span>
    473. 

  473.     <span class="Keyword">else</span><span class="Punctuation">:</span> <span class="StringLit">&quot;zero&quot;</span>
    474. 

  474. 

  475. <span class="Keyword">proc</span> <span class="Identifier">toString</span><span class="Punctuation">(</span><span class="Identifier">x</span><span class="Punctuation">:</span> <span class="Identifier">bool</span><span class="Punctuation">)</span><span class="Punctuation">:</span> <span class="Identifier">string</span> <span class="Operator">=</span>
    476. 

  476.   <span class="Identifier">result</span> <span class="Operator">=</span>
    477. 

  477.     <span class="Keyword">if</span> <span class="Identifier">x</span><span class="Punctuation">:</span> <span class="StringLit">&quot;yep&quot;</span>
    478. 

  478.     <span class="Keyword">else</span><span class="Punctuation">:</span> <span class="StringLit">&quot;nope&quot;</span>
    479. 

  479. 

  480. <span class="Identifier">assert</span> <span class="Identifier">toString</span><span class="Punctuation">(</span><span class="DecNumber">13</span><span class="Punctuation">)</span> <span class="Operator">==</span> <span class="StringLit">&quot;positive&quot;</span> <span class="Comment"># calls the toString(x: int) proc</span>
    481. 

  481. <span class="Identifier">assert</span> <span class="Identifier">toString</span><span class="Punctuation">(</span><span class="Identifier">true</span><span class="Punctuation">)</span> <span class="Operator">==</span> <span class="StringLit">&quot;yep&quot;</span>    <span class="Comment"># calls the toString(x: bool) proc</span></pre></p>
    482. 

  482. <p>(Note that <tt class="docutils literal"><span class="pre"><span class="Identifier">toString</span></span></tt> is usually the <a class="reference external" href="dollars.html">$</a> operator in Nim.) The compiler chooses the most appropriate proc for the <tt class="docutils literal"><span class="pre"><span class="Identifier">toString</span></span></tt> calls. How this overloading resolution algorithm works exactly is not discussed here -- see the manual for details. Ambiguous calls are reported as errors.</p>
    483. 

  483. 

  484. <h2><a class="toc-backref" id="procedures-operators" href="#procedures-operators">Operators</a></h2><p>The Nim standard library makes heavy use of overloading - one reason for this is that each operator like <tt class="docutils literal"><span class="pre"><span class="Operator">+</span></span></tt> is just an overloaded proc. The parser lets you use operators in <em>infix notation</em> (<tt class="docutils literal"><span class="pre"><span class="Identifier">a</span> <span class="Operator">+</span> <span class="Identifier">b</span></span></tt>) or <em>prefix notation</em> (<tt class="docutils literal"><span class="pre"><span class="Operator">+</span> <span class="Identifier">a</span></span></tt>). An infix operator always receives two arguments, a prefix operator always one. (Postfix operators are not possible, because this would be ambiguous: does <tt class="docutils literal"><span class="pre"><span class="Identifier">a</span> <span class="Operator">@</span> <span class="Operator">@</span> <span class="Identifier">b</span></span></tt> mean <tt class="docutils literal"><span class="pre"><span class="Punctuation">(</span><span class="Identifier">a</span><span class="Punctuation">)</span> <span class="Operator">@</span> <span class="Punctuation">(</span><span class="Operator">@</span><span class="Identifier">b</span><span class="Punctuation">)</span></span></tt> or <tt class="docutils literal"><span class="pre"><span class="Punctuation">(</span><span class="Identifier">a</span><span class="Operator">@</span><span class="Punctuation">)</span> <span class="Operator">@</span> <span class="Punctuation">(</span><span class="Identifier">b</span><span class="Punctuation">)</span></span></tt>? It always means <tt class="docutils literal"><span class="pre"><span class="Punctuation">(</span><span class="Identifier">a</span><span class="Punctuation">)</span> <span class="Operator">@</span> <span class="Punctuation">(</span><span class="Operator">@</span><span class="Identifier">b</span><span class="Punctuation">)</span></span></tt>, because there are no postfix operators in Nim.)</p>
    485. 

  485. <p>Apart from a few built-in keyword operators such as <tt class="docutils literal"><span class="pre"><span class="Keyword">and</span></span></tt>, <tt class="docutils literal"><span class="pre"><span class="Keyword">or</span></span></tt>, <tt class="docutils literal"><span class="pre"><span class="Keyword">not</span></span></tt>, operators always consist of these characters: <tt class="docutils literal"><span class="pre"><span class="Operator">+</span> <span class="Operator">-</span> <span class="Operator">*</span> <span class="Operator">\</span> <span class="Operator">/</span> <span class="Operator">&lt;</span> <span class="Operator">&gt;</span> <span class="Operator">=</span> <span class="Operator">@</span> <span class="Operator">$</span> <span class="Operator">~</span> <span class="Operator">&amp;</span> <span class="Operator">%</span> <span class="Operator">!</span> <span class="Operator">?</span> <span class="Operator">^</span> <span class="Operator">.</span> <span class="Operator">|</span></span></tt></p>
    486. 

  486. <p>User-defined operators are allowed. Nothing stops you from defining your own <tt class="docutils literal"><span class="pre"><span class="Operator">@!?+~</span></span></tt> operator, but doing so may reduce readability.</p>
    487. 

  487. <p>The operator's precedence is determined by its first character. The details can be <a class="reference external" href="manual.html#syntax-precedence">found in the manual</a>.</p>
    488. 

  488. <p>To define a new operator enclose the operator in backticks &quot;`&quot;:</p>
    489. 

  489. <p><pre class="listing"><span class="Keyword">proc</span> <span class="Punctuation">`</span><span class="Operator">$</span><span class="Punctuation">`</span> <span class="Punctuation">(</span><span class="Identifier">x</span><span class="Punctuation">:</span> <span class="Identifier">myDataType</span><span class="Punctuation">)</span><span class="Punctuation">:</span> <span class="Identifier">string</span> <span class="Operator">=</span> <span class="Operator">...</span>
    490. 

  490. <span class="Comment"># now the $ operator also works with myDataType, overloading resolution</span>
    491. 

  491. <span class="Comment"># ensures that $ works for built-in types just like before</span></pre></p>
    492. 

  492. <p>The &quot;`&quot; notation can also be used to call an operator just like any other procedure:</p>
    493. 

  493. <p><pre class="listing"><span class="Keyword">if</span> <span class="Punctuation">`</span><span class="Operator">==</span><span class="Punctuation">`</span><span class="Punctuation">(</span> <span class="Punctuation">`</span><span class="Operator">+</span><span class="Punctuation">`</span><span class="Punctuation">(</span><span class="DecNumber">3</span><span class="Punctuation">,</span> <span class="DecNumber">4</span><span class="Punctuation">)</span><span class="Punctuation">,</span> <span class="DecNumber">7</span><span class="Punctuation">)</span><span class="Punctuation">:</span> <span class="Identifier">echo</span> <span class="StringLit">&quot;true&quot;</span></pre></p>
    494. 

  494. 

  495. <h2><a class="toc-backref" id="procedures-forward-declarations" href="#procedures-forward-declarations">Forward declarations</a></h2><p>Every variable, procedure, etc. needs to be declared before it can be used. (The reason for this is that it is non-trivial to avoid this need in a language that supports metaprogramming as extensively as Nim does.) However, this cannot be done for mutually recursive procedures:</p>
    496. 

  496. <p><pre class="listing"><span class="Comment"># forward declaration:</span>
    497. 

  497. <span class="Keyword">proc</span> <span class="Identifier">even</span><span class="Punctuation">(</span><span class="Identifier">n</span><span class="Punctuation">:</span> <span class="Identifier">int</span><span class="Punctuation">)</span><span class="Punctuation">:</span> <span class="Identifier">bool</span></pre></p>
    498. 

  498. <p><pre class="listing"><span class="Keyword">proc</span> <span class="Identifier">odd</span><span class="Punctuation">(</span><span class="Identifier">n</span><span class="Punctuation">:</span> <span class="Identifier">int</span><span class="Punctuation">)</span><span class="Punctuation">:</span> <span class="Identifier">bool</span> <span class="Operator">=</span>
    499. 

  499.   <span class="Identifier">assert</span><span class="Punctuation">(</span><span class="Identifier">n</span> <span class="Operator">&gt;=</span> <span class="DecNumber">0</span><span class="Punctuation">)</span> <span class="Comment"># makes sure we don't run into negative recursion</span>
    500. 

  500.   <span class="Keyword">if</span> <span class="Identifier">n</span> <span class="Operator">==</span> <span class="DecNumber">0</span><span class="Punctuation">:</span> <span class="Identifier">false</span>
    501. 

  501.   <span class="Keyword">else</span><span class="Punctuation">:</span>
    502. 

  502.     <span class="Identifier">n</span> <span class="Operator">==</span> <span class="DecNumber">1</span> <span class="Keyword">or</span> <span class="Identifier">even</span><span class="Punctuation">(</span><span class="Identifier">n</span><span class="Operator">-</span><span class="DecNumber">1</span><span class="Punctuation">)</span>
    503. 

  503. 

  504. <span class="Keyword">proc</span> <span class="Identifier">even</span><span class="Punctuation">(</span><span class="Identifier">n</span><span class="Punctuation">:</span> <span class="Identifier">int</span><span class="Punctuation">)</span><span class="Punctuation">:</span> <span class="Identifier">bool</span> <span class="Operator">=</span>
    505. 

  505.   <span class="Identifier">assert</span><span class="Punctuation">(</span><span class="Identifier">n</span> <span class="Operator">&gt;=</span> <span class="DecNumber">0</span><span class="Punctuation">)</span> <span class="Comment"># makes sure we don't run into negative recursion</span>
    506. 

  506.   <span class="Keyword">if</span> <span class="Identifier">n</span> <span class="Operator">==</span> <span class="DecNumber">1</span><span class="Punctuation">:</span> <span class="Identifier">false</span>
    507. 

  507.   <span class="Keyword">else</span><span class="Punctuation">:</span>
    508. 

  508.     <span class="Identifier">n</span> <span class="Operator">==</span> <span class="DecNumber">0</span> <span class="Keyword">or</span> <span class="Identifier">odd</span><span class="Punctuation">(</span><span class="Identifier">n</span><span class="Operator">-</span><span class="DecNumber">1</span><span class="Punctuation">)</span></pre></p>
    509. 

  509. <p>Here <tt class="docutils literal"><span class="pre"><span class="Identifier">odd</span></span></tt> depends on <tt class="docutils literal"><span class="pre"><span class="Identifier">even</span></span></tt> and vice versa. Thus <tt class="docutils literal"><span class="pre"><span class="Identifier">even</span></span></tt> needs to be introduced to the compiler before it is completely defined. The syntax for such a forward declaration is simple: just omit the <tt class="docutils literal"><span class="pre"><span class="Operator">=</span></span></tt> and the procedure's body. The <tt class="docutils literal"><span class="pre"><span class="Identifier">assert</span></span></tt> just adds border conditions, and will be covered later in <a class="reference internal" href="#modules">Modules</a> section.</p>
    510. 

  510. <p>Later versions of the language will weaken the requirements for forward declarations.</p>
    511. 

  511. <p>The example also shows that a proc's body can consist of a single expression whose value is then returned implicitly.</p>
    512. 

  512. 

  513. <h2><a class="toc-backref" id="procedures-funcs-and-methods" href="#procedures-funcs-and-methods">Funcs and methods</a></h2><p>As mentioned in the introduction, Nim differentiates between procedures, functions, and methods, defined by the <tt class="docutils literal"><span class="pre"><span class="Keyword">proc</span></span></tt>, <tt class="docutils literal"><span class="pre"><span class="Keyword">func</span></span></tt>, and <tt class="docutils literal"><span class="pre"><span class="Keyword">method</span></span></tt> keywords respectively. In some ways, Nim is a bit more pedantic in its definitions than other languages.</p>
    514. 

  514. <p>Functions are closer to the concept of a pure mathematical function, which might be familiar to you if you've ever done functional programming. Essentially they are procedures with additional limitations set on them: they can't access global state (except <tt class="docutils literal"><span class="pre"><span class="Keyword">const</span></span></tt>) and can't produce side-effects. The <tt class="docutils literal"><span class="pre"><span class="Keyword">func</span></span></tt> keyword is basically an alias for <tt class="docutils literal"><span class="pre"><span class="Keyword">proc</span></span></tt> tagged with <tt class="docutils literal"><span class="pre"><span class="Punctuation">{</span><span class="Operator">.</span><span class="Identifier">noSideEffects</span><span class="Operator">.</span><span class="Punctuation">}</span></span></tt>. Functions can still change their mutable arguments however, which are those marked as <tt class="docutils literal"><span class="pre"><span class="Keyword">var</span></span></tt>, along with any <tt class="docutils literal"><span class="pre"><span class="Keyword">ref</span></span></tt> objects.</p>
    515. 

  515. <p>Unlike procedures, methods are dynamically dispatched. This sounds a bit complicated, but it is a concept closely related to inheritance and object-oriented programming. If you overload a procedure (two procedures with the same name but of different types or with different sets of arguments are said to be overloaded), the procedure to use is determined at compile-time. Methods, on the other hand, depend on objects that inherit from the <tt class="docutils literal"><span class="pre"><span class="Identifier">RootObj</span></span></tt>. This is something that is covered in much greater depth in the <a class="reference external" href="tut2.html#object-oriented-programming-dynamic-dispatch">second part of the tutorial</a>.</p>
    516. 

  516. 

  517. <h1><a class="toc-backref" id="iterators" href="#iterators">Iterators</a></h1><p>Let's return to the simple counting example:</p>
    518. 

  518. <p><pre class="listing"><span class="Identifier">echo</span> <span class="StringLit">&quot;Counting to ten: &quot;</span>
    519. 

  519. <span class="Keyword">for</span> <span class="Identifier">i</span> <span class="Keyword">in</span> <span class="Identifier">countup</span><span class="Punctuation">(</span><span class="DecNumber">1</span><span class="Punctuation">,</span> <span class="DecNumber">10</span><span class="Punctuation">)</span><span class="Punctuation">:</span>
    520. 

  520.   <span class="Identifier">echo</span> <span class="Identifier">i</span></pre></p>
    521. 

  521. <p>Can a <a class="reference external" href="system.html#countup.i,T,T,Positive">countup</a> proc be written that supports this loop? Let's try:</p>
    522. 

  522. <p><pre class="listing"><span class="Keyword">proc</span> <span class="Identifier">countup</span><span class="Punctuation">(</span><span class="Identifier">a</span><span class="Punctuation">,</span> <span class="Identifier">b</span><span class="Punctuation">:</span> <span class="Identifier">int</span><span class="Punctuation">)</span><span class="Punctuation">:</span> <span class="Identifier">int</span> <span class="Operator">=</span>
    523. 

  523.   <span class="Keyword">var</span> <span class="Identifier">res</span> <span class="Operator">=</span> <span class="Identifier">a</span>
    524. 

  524.   <span class="Keyword">while</span> <span class="Identifier">res</span> <span class="Operator">&lt;=</span> <span class="Identifier">b</span><span class="Punctuation">:</span>
    525. 

  525.     <span class="Keyword">return</span> <span class="Identifier">res</span>
    526. 

  526.     <span class="Identifier">inc</span><span class="Punctuation">(</span><span class="Identifier">res</span><span class="Punctuation">)</span></pre></p>
    527. 

  527. <p>However, this does not work. The problem is that the procedure should not only <tt class="docutils literal"><span class="pre"><span class="Keyword">return</span></span></tt>, but return and <strong>continue</strong> after an iteration has finished. This <em>return and continue</em> is called a <tt class="docutils literal"><span class="pre"><span class="Keyword">yield</span></span></tt> statement. Now the only thing left to do is to replace the <tt class="docutils literal"><span class="pre"><span class="Keyword">proc</span></span></tt> keyword by <tt class="docutils literal"><span class="pre"><span class="Keyword">iterator</span></span></tt> and here it is -- our first iterator:</p>
    528. 

  528. <p><pre class="listing"><span class="Keyword">iterator</span> <span class="Identifier">countup</span><span class="Punctuation">(</span><span class="Identifier">a</span><span class="Punctuation">,</span> <span class="Identifier">b</span><span class="Punctuation">:</span> <span class="Identifier">int</span><span class="Punctuation">)</span><span class="Punctuation">:</span> <span class="Identifier">int</span> <span class="Operator">=</span>
    529. 

  529.   <span class="Keyword">var</span> <span class="Identifier">res</span> <span class="Operator">=</span> <span class="Identifier">a</span>
    530. 

  530.   <span class="Keyword">while</span> <span class="Identifier">res</span> <span class="Operator">&lt;=</span> <span class="Identifier">b</span><span class="Punctuation">:</span>
    531. 

  531.     <span class="Keyword">yield</span> <span class="Identifier">res</span>
    532. 

  532.     <span class="Identifier">inc</span><span class="Punctuation">(</span><span class="Identifier">res</span><span class="Punctuation">)</span></pre></p>
    533. 

  533. <p>Iterators look very similar to procedures, but there are several important differences:</p>
    534. 

  534. <ul class="simple"><li>Iterators can only be called from for loops.</li>
    535. 

  535. <li>Iterators cannot contain a <tt class="docutils literal"><span class="pre"><span class="Keyword">return</span></span></tt> statement (and procs cannot contain a <tt class="docutils literal"><span class="pre"><span class="Keyword">yield</span></span></tt> statement).</li>
    536. 

  536. <li>Iterators have no implicit <tt class="docutils literal"><span class="pre"><span class="Identifier">result</span></span></tt> variable.</li>
    537. 

  537. <li>Iterators do not support recursion.</li>
    538. 

  538. <li>Iterators cannot be forward declared, because the compiler must be able to inline an iterator. (This restriction will be gone in a future version of the compiler.)</li>
    539. 

  539. </ul>
    540. 

  540. <p>However, you can also use a closure iterator to get a different set of restrictions. See <a class="reference external" href=" manual.html#iterators-and-the-for-statement-firstminusclass-iterators">first-class iterators</a> for details. Iterators can have the same name and parameters as a proc since essentially they have their own namespaces. Therefore, it is common to wrap iterators in procs of the same name which accumulate the result of the iterator and return it as a sequence, like <tt class="docutils literal"><span class="pre"><span class="Identifier">split</span></span></tt> from the <a class="reference external" href=" strutils.html">strutils module</a>.</p>
    541. 

  541. 

  542. <h1><a class="toc-backref" id="basic-types" href="#basic-types">Basic types</a></h1><p>This section deals with the basic built-in types and the operations that are available for them in detail.</p>
    543. 

  543. 

  544. <h2><a class="toc-backref" id="basic-types-booleans" href="#basic-types-booleans">Booleans</a></h2><p>Nim's boolean type is called <tt class="docutils literal"><span class="pre"><span class="Identifier">bool</span></span></tt> and consists of the two pre-defined values <tt class="docutils literal"><span class="pre"><span class="Identifier">true</span></span></tt> and <tt class="docutils literal"><span class="pre"><span class="Identifier">false</span></span></tt>. Conditions in <tt class="docutils literal"><span class="pre"><span class="Keyword">while</span></span></tt>, <tt class="docutils literal"><span class="pre"><span class="Keyword">if</span></span></tt>, <tt class="docutils literal"><span class="pre"><span class="Keyword">elif</span></span></tt>, and <tt class="docutils literal"><span class="pre"><span class="Keyword">when</span></span></tt> statements must be of type bool.</p>
    545. 

  545. <p>The operators <tt class="docutils literal"><span class="pre"><span class="Keyword">not</span><span class="Punctuation">,</span> <span class="Keyword">and</span><span class="Punctuation">,</span> <span class="Keyword">or</span><span class="Punctuation">,</span> <span class="Keyword">xor</span><span class="Punctuation">,</span> <span class="Operator">&lt;</span><span class="Punctuation">,</span> <span class="Operator">&lt;=</span><span class="Punctuation">,</span> <span class="Operator">&gt;</span><span class="Punctuation">,</span> <span class="Operator">&gt;=</span><span class="Punctuation">,</span> <span class="Operator">!=</span><span class="Punctuation">,</span> <span class="Operator">==</span></span></tt> are defined for the bool type. The <tt class="docutils literal"><span class="pre"><span class="Keyword">and</span></span></tt> and <tt class="docutils literal"><span class="pre"><span class="Keyword">or</span></span></tt> operators perform short-circuit evaluation. For example:</p>
    546. 

  546. <p><pre class="listing"><span class="Keyword">while</span> <span class="Identifier">p</span> <span class="Operator">!=</span> <span class="Keyword">nil</span> <span class="Keyword">and</span> <span class="Identifier">p</span><span class="Operator">.</span><span class="Identifier">name</span> <span class="Operator">!=</span> <span class="StringLit">&quot;xyz&quot;</span><span class="Punctuation">:</span>
    547. 

  547.   <span class="Comment"># p.name is not evaluated if p == nil</span>
    548. 

  548.   <span class="Identifier">p</span> <span class="Operator">=</span> <span class="Identifier">p</span><span class="Operator">.</span><span class="Identifier">next</span></pre></p>
    549. 

  549. 

  550. <h2><a class="toc-backref" id="basic-types-characters" href="#basic-types-characters">Characters</a></h2><p>The <em>character type</em> is called <tt class="docutils literal"><span class="pre"><span class="Identifier">char</span></span></tt>. Its size is always one byte, so it cannot represent most UTF-8 characters, but it <em>can</em> represent one of the bytes that makes up a multibyte UTF-8 character. The reason for this is efficiency: for the overwhelming majority of use-cases, the resulting programs will still handle UTF-8 properly as UTF-8 was especially designed for this. Character literals are enclosed in single quotes.</p>
    551. 

  551. <p>Chars can be compared with the <tt class="docutils literal"><span class="pre"><span class="Operator">==</span></span></tt>, <tt class="docutils literal"><span class="pre"><span class="Operator">&lt;</span></span></tt>, <tt class="docutils literal"><span class="pre"><span class="Operator">&lt;=</span></span></tt>, <tt class="docutils literal"><span class="pre"><span class="Operator">&gt;</span></span></tt>, <tt class="docutils literal"><span class="pre"><span class="Operator">&gt;=</span></span></tt> operators. The <tt class="docutils literal"><span class="pre"><span class="Operator">$</span></span></tt> operator converts a <tt class="docutils literal"><span class="pre"><span class="Identifier">char</span></span></tt> to a <tt class="docutils literal"><span class="pre"><span class="Identifier">string</span></span></tt>. Chars cannot be mixed with integers; to get the ordinal value of a <tt class="docutils literal"><span class="pre"><span class="Identifier">char</span></span></tt> use the <tt class="docutils literal"><span class="pre"><span class="Identifier">ord</span></span></tt> proc. Converting from an integer to a <tt class="docutils literal"><span class="pre"><span class="Identifier">char</span></span></tt> is done with the <tt class="docutils literal"><span class="pre"><span class="Identifier">chr</span></span></tt> proc.</p>
    552. 

  552. 

  553. <h2><a class="toc-backref" id="basic-types-strings" href="#basic-types-strings">Strings</a></h2><p>String variables are <strong>mutable</strong>, so appending to a string is possible, and quite efficient. Strings in Nim are both zero-terminated and have a length field. A string's length can be retrieved with the builtin <tt class="docutils literal"><span class="pre"><span class="Identifier">len</span></span></tt> procedure; the length never counts the terminating zero. Accessing the terminating zero is an error, it only exists so that a Nim string can be converted to a <tt class="docutils literal"><span class="pre"><span class="Identifier">cstring</span></span></tt> without doing a copy.</p>
    554. 

  554. <p>The assignment operator for strings copies the string. You can use the <tt class="docutils literal"><span class="pre"><span class="Operator">&amp;</span></span></tt> operator to concatenate strings and <tt class="docutils literal"><span class="pre"><span class="Identifier">add</span></span></tt> to append to a string.</p>
    555. 

  555. <p>Strings are compared using their lexicographical order. All the comparison operators are supported. By convention, all strings are UTF-8 encoded, but this is not enforced. For example, when reading strings from binary files, they are merely a sequence of bytes. The index operation <tt class="docutils literal"><span class="pre"><span class="Identifier">s</span><span class="Punctuation">[</span><span class="Identifier">i</span><span class="Punctuation">]</span></span></tt> means the i-th <em>char</em> of <tt class="docutils literal"><span class="pre"><span class="Identifier">s</span></span></tt>, not the i-th <em>unichar</em>.</p>
    556. 

  556. <p>A string variable is initialized with the empty string <tt class="docutils literal"><span class="pre"><span class="StringLit">&quot;&quot;</span></span></tt>.</p>
    557. 

  557. 

  558. <h2><a class="toc-backref" id="basic-types-integers" href="#basic-types-integers">Integers</a></h2><p>Nim has these integer types built-in: <tt class="docutils literal"><span class="pre"><span class="Identifier">int</span> <span class="Identifier">int8</span> <span class="Identifier">int16</span> <span class="Identifier">int32</span> <span class="Identifier">int64</span> <span class="Identifier">uint</span> <span class="Identifier">uint8</span> <span class="Identifier">uint16</span> <span class="Identifier">uint32</span> <span class="Identifier">uint64</span></span></tt>.</p>
    559. 

  559. <p>The default integer type is <tt class="docutils literal"><span class="pre"><span class="Identifier">int</span></span></tt>. Integer literals can have a <em>type suffix</em> to specify a non-default integer type:</p>
    560. 

  560. <p><pre class="listing"><span class="Keyword">let</span>
    561. 

  561.   <span class="Identifier">x</span> <span class="Operator">=</span> <span class="DecNumber">0</span>     <span class="Comment"># x is of type `int`</span>
    562. 

  562.   <span class="Identifier">y</span> <span class="Operator">=</span> <span class="DecNumber">0'i8</span>  <span class="Comment"># y is of type `int8`</span>
    563. 

  563.   <span class="Identifier">z</span> <span class="Operator">=</span> <span class="DecNumber">0'i32</span> <span class="Comment"># z is of type `int32`</span>
    564. 

  564.   <span class="Identifier">u</span> <span class="Operator">=</span> <span class="DecNumber">0'</span><span class="Identifier">u</span>   <span class="Comment"># u is of type `uint`</span></pre></p>
    565. 

  565. <p>Most often integers are used for counting objects that reside in memory, so <tt class="docutils literal"><span class="pre"><span class="Identifier">int</span></span></tt> has the same size as a pointer.</p>
    566. 

  566. <p>The common operators <tt class="docutils literal"><span class="pre"><span class="Operator">+</span> <span class="Operator">-</span> <span class="Operator">*</span> <span class="Keyword">div</span> <span class="Keyword">mod</span> <span class="Operator">&lt;</span> <span class="Operator">&lt;=</span> <span class="Operator">==</span> <span class="Operator">!=</span> <span class="Operator">&gt;</span> <span class="Operator">&gt;=</span></span></tt> are defined for integers. The <tt class="docutils literal"><span class="pre"><span class="Keyword">and</span> <span class="Keyword">or</span> <span class="Keyword">xor</span> <span class="Keyword">not</span></span></tt> operators are also defined for integers and provide <em>bitwise</em> operations. Left bit shifting is done with the <tt class="docutils literal"><span class="pre"><span class="Keyword">shl</span></span></tt>, right shifting with the <tt class="docutils literal"><span class="pre"><span class="Keyword">shr</span></span></tt> operator. Bit shifting operators always treat their arguments as <em>unsigned</em>. For <span id="arithmetic-bit-shifts_1">arithmetic bit shifts</span> ordinary multiplication or division can be used.</p>
    567. 

  567. <p>Unsigned operations all wrap around; they cannot lead to over- or under-flow errors.</p>
    568. 

  568. <p>Lossless <span id="automatic-type-conversion_1">Automatic type conversion</span> is performed in expressions where different kinds of integer types are used. However, if the type conversion would cause loss of information, the <span id="rangedefect_1">RangeDefect</span> is raised (if the error cannot be detected at compile time).</p>
    569. 

  569. 

  570. <h2><a class="toc-backref" id="basic-types-floats" href="#basic-types-floats">Floats</a></h2><p>Nim has these floating-point types built-in: <tt class="docutils literal"><span class="pre"><span class="Identifier">float</span> <span class="Identifier">float32</span> <span class="Identifier">float64</span></span></tt>.</p>
    571. 

  571. <p>The default float type is <tt class="docutils literal"><span class="pre"><span class="Identifier">float</span></span></tt>. In the current implementation, <tt class="docutils literal"><span class="pre"><span class="Identifier">float</span></span></tt> is always 64-bits.</p>
    572. 

  572. <p>Float literals can have a <em>type suffix</em> to specify a non-default float type:</p>
    573. 

  573. <p><pre class="listing"><span class="Keyword">var</span>
    574. 

  574.   <span class="Identifier">x</span> <span class="Operator">=</span> <span class="FloatNumber">0.0</span>      <span class="Comment"># x is of type `float`</span>
    575. 

  575.   <span class="Identifier">y</span> <span class="Operator">=</span> <span class="FloatNumber">0.0'f32</span>  <span class="Comment"># y is of type `float32`</span>
    576. 

  576.   <span class="Identifier">z</span> <span class="Operator">=</span> <span class="FloatNumber">0.0'f64</span>  <span class="Comment"># z is of type `float64`</span></pre></p>
    577. 

  577. <p>The common operators <tt class="docutils literal"><span class="pre"><span class="Operator">+</span> <span class="Operator">-</span> <span class="Operator">*</span> <span class="Operator">/</span> <span class="Operator">&lt;</span> <span class="Operator">&lt;=</span> <span class="Operator">==</span> <span class="Operator">!=</span> <span class="Operator">&gt;</span> <span class="Operator">&gt;=</span></span></tt> are defined for floats and follow the IEEE-754 standard.</p>
    578. 

  578. <p>Automatic type conversion in expressions with different kinds of floating-point types is performed: the smaller type is converted to the larger. Integer types are <strong>not</strong> converted to floating-point types automatically, nor vice versa. Use the <a class="reference external" href="system.html#toInt,float">toInt</a> and <a class="reference external" href="system.html#toFloat,int">toFloat</a> procs for these conversions.</p>
    579. 

  579. 

  580. <h2><a class="toc-backref" id="basic-types-type-conversion" href="#basic-types-type-conversion">Type Conversion</a></h2><p>Conversion between numerical types is performed by using the type as a function:</p>
    581. 

  581. <p><pre class="listing"><span class="Keyword">var</span>
    582. 

  582.   <span class="Identifier">x</span><span class="Punctuation">:</span> <span class="Identifier">int32</span> <span class="Operator">=</span> <span class="FloatNumber">1.</span><span class="Identifier">int32</span>   <span class="Comment"># same as calling int32(1)</span>
    583. 

  583.   <span class="Identifier">y</span><span class="Punctuation">:</span> <span class="Identifier">int8</span>  <span class="Operator">=</span> <span class="Identifier">int8</span><span class="Punctuation">(</span><span class="Punctuation">'</span><span class="Identifier">a</span><span class="CharLit">') # '</span><span class="Identifier">a</span><span class="CharLit">' == 97'</span><span class="Identifier">i8</span>
    584. 

  584.   <span class="Identifier">z</span><span class="Punctuation">:</span> <span class="Identifier">float</span> <span class="Operator">=</span> <span class="FloatNumber">2.5</span>       <span class="Comment"># int(2.5) rounds down to 2</span>
    585. 

  585.   <span class="Identifier">sum</span><span class="Punctuation">:</span> <span class="Identifier">int</span> <span class="Operator">=</span> <span class="Identifier">int</span><span class="Punctuation">(</span><span class="Identifier">x</span><span class="Punctuation">)</span> <span class="Operator">+</span> <span class="Identifier">int</span><span class="Punctuation">(</span><span class="Identifier">y</span><span class="Punctuation">)</span> <span class="Operator">+</span> <span class="Identifier">int</span><span class="Punctuation">(</span><span class="Identifier">z</span><span class="Punctuation">)</span> <span class="Comment"># sum == 100</span></pre></p>
    586. 

  586. 

  587. <h1><a class="toc-backref" id="internal-type-representation" href="#internal-type-representation">Internal type representation</a></h1><p>As mentioned earlier, the built-in <a class="reference external" href="dollars.html">$</a> (stringify) operator turns any basic type into a string, which you can then print to the console using the <tt class="docutils literal"><span class="pre"><span class="Identifier">echo</span></span></tt> proc. However, advanced types, and your own custom types, won't work with the <tt class="docutils literal"><span class="pre"><span class="Operator">$</span></span></tt> operator until you define it for them. Sometimes you just want to debug the current value of a complex type without having to write its <tt class="docutils literal"><span class="pre"><span class="Operator">$</span></span></tt> operator.  You can use then the <a class="reference external" href=" system.html#repr,T">repr</a> proc which works with any type and even complex data graphs with cycles. The following example shows that even for basic types there is a difference between the <tt class="docutils literal"><span class="pre"><span class="Operator">$</span></span></tt> and <tt class="docutils literal"><span class="pre"><span class="Identifier">repr</span></span></tt> outputs:</p>
    588. 

  588. <p><pre class="listing"><span class="Keyword">var</span>
    589. 

  589.   <span class="Identifier">myBool</span> <span class="Operator">=</span> <span class="Identifier">true</span>
    590. 

  590.   <span class="Identifier">myCharacter</span> <span class="Operator">=</span> <span class="CharLit">'n'</span>
    591. 

  591.   <span class="Identifier">myString</span> <span class="Operator">=</span> <span class="StringLit">&quot;nim&quot;</span>
    592. 

  592.   <span class="Identifier">myInteger</span> <span class="Operator">=</span> <span class="DecNumber">42</span>
    593. 

  593.   <span class="Identifier">myFloat</span> <span class="Operator">=</span> <span class="FloatNumber">3.14</span>
    594. 

  594. <span class="Identifier">echo</span> <span class="Identifier">myBool</span><span class="Punctuation">,</span> <span class="StringLit">&quot;:&quot;</span><span class="Punctuation">,</span> <span class="Identifier">repr</span><span class="Punctuation">(</span><span class="Identifier">myBool</span><span class="Punctuation">)</span>
    595. 

  595. <span class="Comment"># --&gt; true:true</span>
    596. 

  596. <span class="Identifier">echo</span> <span class="Identifier">myCharacter</span><span class="Punctuation">,</span> <span class="StringLit">&quot;:&quot;</span><span class="Punctuation">,</span> <span class="Identifier">repr</span><span class="Punctuation">(</span><span class="Identifier">myCharacter</span><span class="Punctuation">)</span>
    597. 

  597. <span class="Comment"># --&gt; n:'n'</span>
    598. 

  598. <span class="Identifier">echo</span> <span class="Identifier">myString</span><span class="Punctuation">,</span> <span class="StringLit">&quot;:&quot;</span><span class="Punctuation">,</span> <span class="Identifier">repr</span><span class="Punctuation">(</span><span class="Identifier">myString</span><span class="Punctuation">)</span>
    599. 

  599. <span class="Comment"># --&gt; nim:0x10fa8c050&quot;nim&quot;</span>
    600. 

  600. <span class="Identifier">echo</span> <span class="Identifier">myInteger</span><span class="Punctuation">,</span> <span class="StringLit">&quot;:&quot;</span><span class="Punctuation">,</span> <span class="Identifier">repr</span><span class="Punctuation">(</span><span class="Identifier">myInteger</span><span class="Punctuation">)</span>
    601. 

  601. <span class="Comment"># --&gt; 42:42</span>
    602. 

  602. <span class="Identifier">echo</span> <span class="Identifier">myFloat</span><span class="Punctuation">,</span> <span class="StringLit">&quot;:&quot;</span><span class="Punctuation">,</span> <span class="Identifier">repr</span><span class="Punctuation">(</span><span class="Identifier">myFloat</span><span class="Punctuation">)</span>
    603. 

  603. <span class="Comment"># --&gt; 3.14:3.14</span></pre></p>
    604. 

  604. 

  605. <h1><a class="toc-backref" id="advanced-types" href="#advanced-types">Advanced types</a></h1><p>In Nim new types can be defined within a <tt class="docutils literal"><span class="pre"><span class="Keyword">type</span></span></tt> statement:</p>
    606. 

  606. <p><pre class="listing"><span class="Keyword">type</span>
    607. 

  607.   <span class="Identifier">biggestInt</span> <span class="Operator">=</span> <span class="Identifier">int64</span>      <span class="Comment"># biggest integer type that is available</span>
    608. 

  608.   <span class="Identifier">biggestFloat</span> <span class="Operator">=</span> <span class="Identifier">float64</span>  <span class="Comment"># biggest float type that is available</span></pre></p>
    609. 

  609. <p>Enumeration and object types may only be defined within a <tt class="docutils literal"><span class="pre"><span class="Keyword">type</span></span></tt> statement.</p>
    610. 

  610. 

  611. <h2><a class="toc-backref" id="advanced-types-enumerations" href="#advanced-types-enumerations">Enumerations</a></h2><p>A variable of an enumeration type can only be assigned one of the enumeration's specified values. These values are a set of ordered symbols. Each symbol is mapped to an integer value internally. The first symbol is represented at runtime by 0, the second by 1, and so on. For example:</p>
    612. 

  612. <p><pre class="listing"><span class="Keyword">type</span>
    613. 

  613.   <span class="Identifier">Direction</span> <span class="Operator">=</span> <span class="Keyword">enum</span>
    614. 

  614.     <span class="Identifier">north</span><span class="Punctuation">,</span> <span class="Identifier">east</span><span class="Punctuation">,</span> <span class="Identifier">south</span><span class="Punctuation">,</span> <span class="Identifier">west</span>
    615. 

  615. 

  616. <span class="Keyword">var</span> <span class="Identifier">x</span> <span class="Operator">=</span> <span class="Identifier">south</span>     <span class="Comment"># `x` is of type `Direction`; its value is `south`</span>
    617. 

  617. <span class="Identifier">echo</span> <span class="Identifier">x</span>            <span class="Comment"># prints &quot;south&quot;</span>
    618. 

  618. 

  619. <span class="Keyword">if</span> <span class="Identifier">x</span> <span class="Operator">==</span> <span class="Identifier">Direction</span><span class="Operator">.</span><span class="Identifier">south</span><span class="Punctuation">:</span>
    620. 

  620.   <span class="Identifier">echo</span> <span class="StringLit">&quot;It's south!&quot;</span></pre></p>
    621. 

  621. <p>All the comparison operators can be used with enumeration types.</p>
    622. 

  622. <p>An enumeration's symbol can be qualified to avoid ambiguities: <tt class="docutils literal"><span class="pre"><span class="Identifier">Direction</span><span class="Operator">.</span><span class="Identifier">south</span></span></tt>.</p>
    623. 

  623. <p>The <tt class="docutils literal"><span class="pre"><span class="Operator">$</span></span></tt> operator can convert any enumeration value to its name, and the <tt class="docutils literal"><span class="pre"><span class="Identifier">ord</span></span></tt> proc can convert it to its underlying integer value.</p>
    624. 

  624. <p>For better interfacing to other programming languages, the symbols of enum types can be assigned an explicit ordinal value. However, the ordinal values must be in ascending order.</p>
    625. 

  625. 

  626. <h2><a class="toc-backref" id="advanced-types-ordinal-types" href="#advanced-types-ordinal-types">Ordinal types</a></h2><p>Enumerations, integer types, <tt class="docutils literal"><span class="pre"><span class="Identifier">char</span></span></tt> and <tt class="docutils literal"><span class="pre"><span class="Identifier">bool</span></span></tt> (and subranges) are called ordinal types. Ordinal types have quite a few special operations:</p>
    627. 

  627. <table border="1" class="docutils"><tr><th>Operation</th><th>Comment</th></tr>
    628. 

  628. <tr><td><tt class="docutils literal"><span class="pre"><span class="Identifier">ord</span><span class="Punctuation">(</span><span class="Identifier">x</span><span class="Punctuation">)</span></span></tt></td><td>returns the integer value that is used to represent <tt class="docutils literal"><span class="pre"><span class="Identifier">x</span></span></tt>'s value</td></tr>
    629. 

  629. <tr><td><tt class="docutils literal"><span class="pre"><span class="Identifier">inc</span><span class="Punctuation">(</span><span class="Identifier">x</span><span class="Punctuation">)</span></span></tt></td><td>increments <tt class="docutils literal"><span class="pre"><span class="Identifier">x</span></span></tt> by one</td></tr>
    630. 

  630. <tr><td><tt class="docutils literal"><span class="pre"><span class="Identifier">inc</span><span class="Punctuation">(</span><span class="Identifier">x</span><span class="Punctuation">,</span> <span class="Identifier">n</span><span class="Punctuation">)</span></span></tt></td><td>increments <tt class="docutils literal"><span class="pre"><span class="Identifier">x</span></span></tt> by <tt class="docutils literal"><span class="pre"><span class="Identifier">n</span></span></tt>; <tt class="docutils literal"><span class="pre"><span class="Identifier">n</span></span></tt> is an integer</td></tr>
    631. 

  631. <tr><td><tt class="docutils literal"><span class="pre"><span class="Identifier">dec</span><span class="Punctuation">(</span><span class="Identifier">x</span><span class="Punctuation">)</span></span></tt></td><td>decrements <tt class="docutils literal"><span class="pre"><span class="Identifier">x</span></span></tt> by one</td></tr>
    632. 

  632. <tr><td><tt class="docutils literal"><span class="pre"><span class="Identifier">dec</span><span class="Punctuation">(</span><span class="Identifier">x</span><span class="Punctuation">,</span> <span class="Identifier">n</span><span class="Punctuation">)</span></span></tt></td><td>decrements <tt class="docutils literal"><span class="pre"><span class="Identifier">x</span></span></tt> by <tt class="docutils literal"><span class="pre"><span class="Identifier">n</span></span></tt>; <tt class="docutils literal"><span class="pre"><span class="Identifier">n</span></span></tt> is an integer</td></tr>
    633. 

  633. <tr><td><tt class="docutils literal"><span class="pre"><span class="Identifier">succ</span><span class="Punctuation">(</span><span class="Identifier">x</span><span class="Punctuation">)</span></span></tt></td><td>returns the successor of <tt class="docutils literal"><span class="pre"><span class="Identifier">x</span></span></tt></td></tr>
    634. 

  634. <tr><td><tt class="docutils literal"><span class="pre"><span class="Identifier">succ</span><span class="Punctuation">(</span><span class="Identifier">x</span><span class="Punctuation">,</span> <span class="Identifier">n</span><span class="Punctuation">)</span></span></tt></td><td>returns the <tt class="docutils literal"><span class="pre"><span class="Identifier">n</span></span></tt>'th successor of <tt class="docutils literal"><span class="pre"><span class="Identifier">x</span></span></tt></td></tr>
    635. 

  635. <tr><td><tt class="docutils literal"><span class="pre"><span class="Identifier">pred</span><span class="Punctuation">(</span><span class="Identifier">x</span><span class="Punctuation">)</span></span></tt></td><td>returns the predecessor of <tt class="docutils literal"><span class="pre"><span class="Identifier">x</span></span></tt></td></tr>
    636. 

  636. <tr><td><tt class="docutils literal"><span class="pre"><span class="Identifier">pred</span><span class="Punctuation">(</span><span class="Identifier">x</span><span class="Punctuation">,</span> <span class="Identifier">n</span><span class="Punctuation">)</span></span></tt></td><td>returns the <tt class="docutils literal"><span class="pre"><span class="Identifier">n</span></span></tt>'th predecessor of <tt class="docutils literal"><span class="pre"><span class="Identifier">x</span></span></tt></td></tr>
    637. 

  637. </table><p>The <a class="reference external" href="system.html#inc,T,int">inc</a>, <a class="reference external" href="system.html#dec,T,int">dec</a>, <a class="reference external" href=" system.html#succ,T,int">succ</a> and <a class="reference external" href="system.html#pred,T,int">pred</a> operations can fail by raising an <tt class="docutils literal"><span class="pre"><span class="Identifier">RangeDefect</span></span></tt> or <tt class="docutils literal"><span class="pre"><span class="Identifier">OverflowDefect</span></span></tt>. (If the code has been compiled with the proper runtime checks turned on.)</p>
    638. 

  638. 

  639. <h2><a class="toc-backref" id="advanced-types-subranges" href="#advanced-types-subranges">Subranges</a></h2><p>A subrange type is a range of values from an integer or enumeration type (the base type). Example:</p>
    640. 

  640. <p><pre class="listing"><span class="Keyword">type</span>
    641. 

  641.   <span class="Identifier">MySubrange</span> <span class="Operator">=</span> <span class="Identifier">range</span><span class="Punctuation">[</span><span class="FloatNumber">0.</span><span class="Operator">.</span><span class="DecNumber">5</span><span class="Punctuation">]</span></pre></p>
    642. 

  642. <p><tt class="docutils literal"><span class="pre"><span class="Identifier">MySubrange</span></span></tt> is a subrange of <tt class="docutils literal"><span class="pre"><span class="Identifier">int</span></span></tt> which can only hold the values 0 to 5. Assigning any other value to a variable of type <tt class="docutils literal"><span class="pre"><span class="Identifier">MySubrange</span></span></tt> is a compile-time or runtime error. Assignments from the base type to one of its subrange types (and vice versa) are allowed.</p>
    643. 

  643. <p>The <tt class="docutils literal"><span class="pre"><span class="Identifier">system</span></span></tt> module defines the important <a class="reference external" href="system.html#Natural">Natural</a> type as <tt class="docutils literal"><span class="pre"><span class="Identifier">range</span><span class="Punctuation">[</span><span class="FloatNumber">0.</span><span class="Operator">.</span><span class="Identifier">high</span><span class="Punctuation">(</span><span class="Identifier">int</span><span class="Punctuation">)</span><span class="Punctuation">]</span></span></tt> (<a class="reference external" href="system.html#high,typedesc[T]">high</a> returns the maximal value). Other programming languages may suggest the use of unsigned integers for natural numbers. This is often <strong>unwise</strong>: you don't want unsigned arithmetic (which wraps around) just because the numbers cannot be negative. Nim's <tt class="docutils literal"><span class="pre"><span class="Identifier">Natural</span></span></tt> type helps to avoid this common programming error.</p>
    644. 

  644. 

  645. <h2><a class="toc-backref" id="advanced-types-sets" href="#advanced-types-sets">Sets</a></h2>The set type models the mathematical notion of a set. The set's basetype can only be an ordinal type of a certain size, namely:<ul class="simple"><li><tt class="docutils literal"><span class="pre"><span class="Identifier">int8</span></span></tt>-<tt class="docutils literal"><span class="pre"><span class="Identifier">int16</span></span></tt></li>
    646. 

  646. <li><tt class="docutils literal"><span class="pre"><span class="Identifier">uint8</span></span></tt>/<tt class="docutils literal"><span class="pre"><span class="Identifier">byte</span></span></tt>-<tt class="docutils literal"><span class="pre"><span class="Identifier">uint16</span></span></tt></li>
    647. 

  647. <li><tt class="docutils literal"><span class="pre"><span class="Identifier">char</span></span></tt></li>
    648. 

  648. <li><tt class="docutils literal"><span class="pre"><span class="Keyword">enum</span></span></tt></li>
    649. 

  649. <li>Ordinal subrange types, i.e. <tt class="docutils literal"><span class="pre"><span class="Identifier">range</span><span class="Punctuation">[</span><span class="Operator">-</span><span class="FloatNumber">10.</span><span class="Operator">.</span><span class="DecNumber">10</span><span class="Punctuation">]</span></span></tt></li>
    650. 

  650. </ul>
    651. 

  651. <p>or equivalent. When constructing a set with signed integer literals, the set's base type is defined to be in the range <tt class="docutils literal"><span class="pre"><span class="DecNumber">0</span> <span class="Operator">..</span> <span class="Identifier">DefaultSetElements</span><span class="Operator">-</span><span class="DecNumber">1</span></span></tt> where <tt class="docutils literal"><span class="pre"><span class="Identifier">DefaultSetElements</span></span></tt> is currently always 2^8. The maximum range length for the base type of a set is <tt class="docutils literal"><span class="pre"><span class="Identifier">MaxSetElements</span></span></tt> which is currently always 2^16. Types with a bigger range length are coerced into the range <tt class="docutils literal"><span class="pre"><span class="DecNumber">0</span> <span class="Operator">..</span> <span class="Identifier">MaxSetElements</span><span class="Operator">-</span><span class="DecNumber">1</span></span></tt>.</p>
    652. 

  652. <p>The reason is that sets are implemented as high performance bit vectors. Attempting to declare a set with a larger type will result in an error:</p>
    653. 

  653. <p><pre class="listing">  <span class="Keyword">var</span> <span class="Identifier">s</span><span class="Punctuation">:</span> <span class="Identifier">set</span><span class="Punctuation">[</span><span class="Identifier">int64</span><span class="Punctuation">]</span> <span class="Comment"># Error: set is too large; use `std/sets` for ordinal types</span>
    654. 

  654.                     <span class="Comment"># with more than 2^16 elements</span></pre></p>
    655. 

  655. <p><strong>Note:</strong> Nim also offers <a class="reference external" href="sets.html">hash sets</a> (which you need to import with <tt class="docutils literal"><span class="pre"><span class="Keyword">import</span> <span class="Identifier">std</span><span class="Operator">/</span><span class="Identifier">sets</span></span></tt>), which have no such restrictions.</p>
    656. 

  656. <p>Sets can be constructed via the set constructor: <tt class="docutils literal"><span class="pre"><span class="Punctuation">{</span><span class="Punctuation">}</span></span></tt> is the empty set. The empty set is type compatible with any concrete set type. The constructor can also be used to include elements (and ranges of elements):</p>
    657. 

  657. <p><pre class="listing"><span class="Keyword">type</span>
    658. 

  658.   <span class="Identifier">CharSet</span> <span class="Operator">=</span> <span class="Identifier">set</span><span class="Punctuation">[</span><span class="Identifier">char</span><span class="Punctuation">]</span>
    659. 

  659. <span class="Keyword">var</span>
    660. 

  660.   <span class="Identifier">x</span><span class="Punctuation">:</span> <span class="Identifier">CharSet</span>
    661. 

  661. <span class="Identifier">x</span> <span class="Operator">=</span> <span class="Punctuation">{</span><span class="Punctuation">'</span><span class="Identifier">a</span><span class="CharLit">'..'</span><span class="Identifier">z</span><span class="CharLit">', '</span><span class="DecNumber">0'</span><span class="Operator">..</span><span class="CharLit">'9'</span><span class="Punctuation">}</span> <span class="Comment"># This constructs a set that contains the</span>
    662. 

  662.                          <span class="Comment"># letters from 'a' to 'z' and the digits</span>
    663. 

  663.                          <span class="Comment"># from '0' to '9'</span></pre></p>
    664. 

  664. <p>The module <a class="reference external" href="setutils.html">`std/setutils`</a> provides a way to initialize a set from an iterable:</p>
    665. 

  665. <p><pre class="listing"><span class="Keyword">import</span> <span class="Identifier">std</span><span class="Operator">/</span><span class="Identifier">setutils</span>
    666. 

  666. 

  667. <span class="Keyword">let</span> <span class="Identifier">uniqueChars</span> <span class="Operator">=</span> <span class="Identifier">myString</span><span class="Operator">.</span><span class="Identifier">toSet</span></pre></p>
    668. 

  668. <p>These operations are supported by sets:</p>
    669. 

  669. <table border="1" class="docutils"><tr><th>operation</th><th>meaning</th></tr>
    670. 

  670. <tr><td><tt class="docutils literal"><span class="pre"><span class="Identifier">A</span> <span class="Operator">+</span> <span class="Identifier">B</span></span></tt></td><td>union of two sets</td></tr>
    671. 

  671. <tr><td><tt class="docutils literal"><span class="pre"><span class="Identifier">A</span> <span class="Operator">*</span> <span class="Identifier">B</span></span></tt></td><td>intersection of two sets</td></tr>
    672. 

  672. <tr><td><tt class="docutils literal"><span class="pre"><span class="Identifier">A</span> <span class="Operator">-</span> <span class="Identifier">B</span></span></tt></td><td>difference of two sets (A without B's elements)</td></tr>
    673. 

  673. <tr><td><tt class="docutils literal"><span class="pre"><span class="Identifier">A</span> <span class="Operator">==</span> <span class="Identifier">B</span></span></tt></td><td>set equality</td></tr>
    674. 

  674. <tr><td><tt class="docutils literal"><span class="pre"><span class="Identifier">A</span> <span class="Operator">&lt;=</span> <span class="Identifier">B</span></span></tt></td><td>subset relation (A is subset of B or equal to B)</td></tr>
    675. 

  675. <tr><td><tt class="docutils literal"><span class="pre"><span class="Identifier">A</span> <span class="Operator">&lt;</span> <span class="Identifier">B</span></span></tt></td><td>strict subset relation (A is a proper subset of B)</td></tr>
    676. 

  676. <tr><td><tt class="docutils literal"><span class="pre"><span class="Identifier">e</span> <span class="Keyword">in</span> <span class="Identifier">A</span></span></tt></td><td>set membership (A contains element e)</td></tr>
    677. 

  677. <tr><td><tt class="docutils literal"><span class="pre"><span class="Identifier">e</span> <span class="Keyword">notin</span> <span class="Identifier">A</span></span></tt></td><td>A does not contain element e</td></tr>
    678. 

  678. <tr><td><tt class="docutils literal"><span class="pre"><span class="Identifier">contains</span><span class="Punctuation">(</span><span class="Identifier">A</span><span class="Punctuation">,</span> <span class="Identifier">e</span><span class="Punctuation">)</span></span></tt></td><td>A contains element e</td></tr>
    679. 

  679. <tr><td><tt class="docutils literal"><span class="pre"><span class="Identifier">card</span><span class="Punctuation">(</span><span class="Identifier">A</span><span class="Punctuation">)</span></span></tt></td><td>the cardinality of A (number of elements in A)</td></tr>
    680. 

  680. <tr><td><tt class="docutils literal"><span class="pre"><span class="Identifier">incl</span><span class="Punctuation">(</span><span class="Identifier">A</span><span class="Punctuation">,</span> <span class="Identifier">elem</span><span class="Punctuation">)</span></span></tt></td><td>same as <tt class="docutils literal"><span class="pre"><span class="Identifier">A</span> <span class="Operator">=</span> <span class="Identifier">A</span> <span class="Operator">+</span> <span class="Punctuation">{</span><span class="Identifier">elem</span><span class="Punctuation">}</span></span></tt></td></tr>
    681. 

  681. <tr><td><tt class="docutils literal"><span class="pre"><span class="Identifier">excl</span><span class="Punctuation">(</span><span class="Identifier">A</span><span class="Punctuation">,</span> <span class="Identifier">elem</span><span class="Punctuation">)</span></span></tt></td><td>same as <tt class="docutils literal"><span class="pre"><span class="Identifier">A</span> <span class="Operator">=</span> <span class="Identifier">A</span> <span class="Operator">-</span> <span class="Punctuation">{</span><span class="Identifier">elem</span><span class="Punctuation">}</span></span></tt></td></tr>
    682. 

  682. </table>
    683. 

  683. <h3><a class="toc-backref" id="sets-bit-fields" href="#sets-bit-fields">Bit fields</a></h3><p>Sets are often used to define a type for the <em>flags</em> of a procedure. This is a cleaner (and type safe) solution than defining integer constants that have to be <tt class="docutils literal"><span class="pre"><span class="Keyword">or</span></span></tt>'ed together.</p>
    684. 

  684. <p>Enum, sets and casting can be used together as in:</p>
    685. 

  685. <p><pre class="listing"><span class="Keyword">type</span>
    686. 

  686.   <span class="Identifier">MyFlag</span><span class="Operator">*</span> <span class="Punctuation">{</span><span class="Operator">.</span><span class="Identifier">size</span><span class="Punctuation">:</span> <span class="Identifier">sizeof</span><span class="Punctuation">(</span><span class="Identifier">cint</span><span class="Punctuation">)</span><span class="Operator">.</span><span class="Punctuation">}</span> <span class="Operator">=</span> <span class="Keyword">enum</span>
    687. 

  687.     <span class="Identifier">A</span>
    688. 

  688.     <span class="Identifier">B</span>
    689. 

  689.     <span class="Identifier">C</span>
    690. 

  690.     <span class="Identifier">D</span>
    691. 

  691.   <span class="Identifier">MyFlags</span> <span class="Operator">=</span> <span class="Identifier">set</span><span class="Punctuation">[</span><span class="Identifier">MyFlag</span><span class="Punctuation">]</span>
    692. 

  692. 

  693. <span class="Keyword">proc</span> <span class="Identifier">toNum</span><span class="Punctuation">(</span><span class="Identifier">f</span><span class="Punctuation">:</span> <span class="Identifier">MyFlags</span><span class="Punctuation">)</span><span class="Punctuation">:</span> <span class="Identifier">int</span> <span class="Operator">=</span> <span class="Keyword">cast</span><span class="Punctuation">[</span><span class="Identifier">cint</span><span class="Punctuation">]</span><span class="Punctuation">(</span><span class="Identifier">f</span><span class="Punctuation">)</span>
    694. 

  694. <span class="Keyword">proc</span> <span class="Identifier">toFlags</span><span class="Punctuation">(</span><span class="Identifier">v</span><span class="Punctuation">:</span> <span class="Identifier">int</span><span class="Punctuation">)</span><span class="Punctuation">:</span> <span class="Identifier">MyFlags</span> <span class="Operator">=</span> <span class="Keyword">cast</span><span class="Punctuation">[</span><span class="Identifier">MyFlags</span><span class="Punctuation">]</span><span class="Punctuation">(</span><span class="Identifier">v</span><span class="Punctuation">)</span>
    695. 

  695. 

  696. <span class="Identifier">assert</span> <span class="Identifier">toNum</span><span class="Punctuation">(</span><span class="Punctuation">{</span><span class="Punctuation">}</span><span class="Punctuation">)</span> <span class="Operator">==</span> <span class="DecNumber">0</span>
    697. 

  697. <span class="Identifier">assert</span> <span class="Identifier">toNum</span><span class="Punctuation">(</span><span class="Punctuation">{</span><span class="Identifier">A</span><span class="Punctuation">}</span><span class="Punctuation">)</span> <span class="Operator">==</span> <span class="DecNumber">1</span>
    698. 

  698. <span class="Identifier">assert</span> <span class="Identifier">toNum</span><span class="Punctuation">(</span><span class="Punctuation">{</span><span class="Identifier">D</span><span class="Punctuation">}</span><span class="Punctuation">)</span> <span class="Operator">==</span> <span class="DecNumber">8</span>
    699. 

  699. <span class="Identifier">assert</span> <span class="Identifier">toNum</span><span class="Punctuation">(</span><span class="Punctuation">{</span><span class="Identifier">A</span><span class="Punctuation">,</span> <span class="Identifier">C</span><span class="Punctuation">}</span><span class="Punctuation">)</span> <span class="Operator">==</span> <span class="DecNumber">5</span>
    700. 

  700. <span class="Identifier">assert</span> <span class="Identifier">toFlags</span><span class="Punctuation">(</span><span class="DecNumber">0</span><span class="Punctuation">)</span> <span class="Operator">==</span> <span class="Punctuation">{</span><span class="Punctuation">}</span>
    701. 

  701. <span class="Identifier">assert</span> <span class="Identifier">toFlags</span><span class="Punctuation">(</span><span class="DecNumber">7</span><span class="Punctuation">)</span> <span class="Operator">==</span> <span class="Punctuation">{</span><span class="Identifier">A</span><span class="Punctuation">,</span> <span class="Identifier">B</span><span class="Punctuation">,</span> <span class="Identifier">C</span><span class="Punctuation">}</span></pre></p>
    702. 

  702. <p>Note how the set turns enum values into powers of 2.</p>
    703. 

  703. <p>If using enums and sets with C, use distinct cint.</p>
    704. 

  704. <p>For interoperability with C see also the <a class="reference external" href="manual.html#implementation-specific-pragmas-bitsize-pragma">bitsize pragma</a>. </p>
    705. 

  705. 

  706. <h2><a class="toc-backref" id="advanced-types-arrays" href="#advanced-types-arrays">Arrays</a></h2><p>An array is a simple fixed-length container. Each element in an array has the same type. The array's index type can be any ordinal type.</p>
    707. 

  707. <p>Arrays can be constructed using <tt class="docutils literal"><span class="pre"><span class="Punctuation">[</span><span class="Punctuation">]</span></span></tt>:</p>
    708. 

  708. <p><pre class="listing"><span class="Keyword">type</span>
    709. 

  709.   <span class="Identifier">IntArray</span> <span class="Operator">=</span> <span class="Identifier">array</span><span class="Punctuation">[</span><span class="FloatNumber">0.</span><span class="Operator">.</span><span class="DecNumber">5</span><span class="Punctuation">,</span> <span class="Identifier">int</span><span class="Punctuation">]</span> <span class="Comment"># an array that is indexed with 0..5</span>
    710. 

  710. <span class="Keyword">var</span>
    711. 

  711.   <span class="Identifier">x</span><span class="Punctuation">:</span> <span class="Identifier">IntArray</span>
    712. 

  712. <span class="Identifier">x</span> <span class="Operator">=</span> <span class="Punctuation">[</span><span class="DecNumber">1</span><span class="Punctuation">,</span> <span class="DecNumber">2</span><span class="Punctuation">,</span> <span class="DecNumber">3</span><span class="Punctuation">,</span> <span class="DecNumber">4</span><span class="Punctuation">,</span> <span class="DecNumber">5</span><span class="Punctuation">,</span> <span class="DecNumber">6</span><span class="Punctuation">]</span>
    713. 

  713. <span class="Keyword">for</span> <span class="Identifier">i</span> <span class="Keyword">in</span> <span class="Identifier">low</span><span class="Punctuation">(</span><span class="Identifier">x</span><span class="Punctuation">)</span> <span class="Operator">..</span> <span class="Identifier">high</span><span class="Punctuation">(</span><span class="Identifier">x</span><span class="Punctuation">)</span><span class="Punctuation">:</span>
    714. 

  714.   <span class="Identifier">echo</span> <span class="Identifier">x</span><span class="Punctuation">[</span><span class="Identifier">i</span><span class="Punctuation">]</span></pre></p>
    715. 

  715. <p>The notation <tt class="docutils literal"><span class="pre"><span class="Identifier">x</span><span class="Punctuation">[</span><span class="Identifier">i</span><span class="Punctuation">]</span></span></tt> is used to access the i-th element of <tt class="docutils literal"><span class="pre"><span class="Identifier">x</span></span></tt>. Array access is always bounds checked (at compile-time or at runtime). These checks can be disabled via pragmas or invoking the compiler with the <tt class="docutils literal"><span class="pre">--bound_checks:off</span></tt> command line switch.</p>
    716. 

  716. <p>Arrays are value types, like any other Nim type. The assignment operator copies the whole array contents.</p>
    717. 

  717. <p>The built-in <a class="reference external" href="system.html#len,TOpenArray">len</a> proc returns the array's length. <a class="reference external" href="system.html#low,openArray[T]">low(a)</a> returns the lowest valid index for the array <tt class="docutils literal"><span class="pre"><span class="Identifier">a</span></span></tt> and <a class="reference external" href="system.html#high,openArray[T]">high(a)</a> the highest valid index.</p>
    718. 

  718. <p><pre class="listing"><span class="Keyword">type</span>
    719. 

  719.   <span class="Identifier">Direction</span> <span class="Operator">=</span> <span class="Keyword">enum</span>
    720. 

  720.     <span class="Identifier">north</span><span class="Punctuation">,</span> <span class="Identifier">east</span><span class="Punctuation">,</span> <span class="Identifier">south</span><span class="Punctuation">,</span> <span class="Identifier">west</span>
    721. 

  721.   <span class="Identifier">BlinkLights</span> <span class="Operator">=</span> <span class="Keyword">enum</span>
    722. 

  722.     <span class="Identifier">off</span><span class="Punctuation">,</span> <span class="Identifier">on</span><span class="Punctuation">,</span> <span class="Identifier">slowBlink</span><span class="Punctuation">,</span> <span class="Identifier">mediumBlink</span><span class="Punctuation">,</span> <span class="Identifier">fastBlink</span>
    723. 

  723.   <span class="Identifier">LevelSetting</span> <span class="Operator">=</span> <span class="Identifier">array</span><span class="Punctuation">[</span><span class="Identifier">north</span><span class="Operator">..</span><span class="Identifier">west</span><span class="Punctuation">,</span> <span class="Identifier">BlinkLights</span><span class="Punctuation">]</span>
    724. 

  724. <span class="Keyword">var</span>
    725. 

  725.   <span class="Identifier">level</span><span class="Punctuation">:</span> <span class="Identifier">LevelSetting</span>
    726. 

  726. <span class="Identifier">level</span><span class="Punctuation">[</span><span class="Identifier">north</span><span class="Punctuation">]</span> <span class="Operator">=</span> <span class="Identifier">on</span>
    727. 

  727. <span class="Identifier">level</span><span class="Punctuation">[</span><span class="Identifier">south</span><span class="Punctuation">]</span> <span class="Operator">=</span> <span class="Identifier">slowBlink</span>
    728. 

  728. <span class="Identifier">level</span><span class="Punctuation">[</span><span class="Identifier">east</span><span class="Punctuation">]</span> <span class="Operator">=</span> <span class="Identifier">fastBlink</span>
    729. 

  729. <span class="Identifier">echo</span> <span class="Identifier">level</span>        <span class="Comment"># --&gt; [on, fastBlink, slowBlink, off]</span>
    730. 

  730. <span class="Identifier">echo</span> <span class="Identifier">low</span><span class="Punctuation">(</span><span class="Identifier">level</span><span class="Punctuation">)</span>   <span class="Comment"># --&gt; north</span>
    731. 

  731. <span class="Identifier">echo</span> <span class="Identifier">len</span><span class="Punctuation">(</span><span class="Identifier">level</span><span class="Punctuation">)</span>   <span class="Comment"># --&gt; 4</span>
    732. 

  732. <span class="Identifier">echo</span> <span class="Identifier">high</span><span class="Punctuation">(</span><span class="Identifier">level</span><span class="Punctuation">)</span>  <span class="Comment"># --&gt; west</span></pre></p>
    733. 

  733. <p>The syntax for nested arrays (multidimensional) in other languages is a matter of appending more brackets because usually each dimension is restricted to the same index type as the others. In Nim you can have different dimensions with different index types, so the nesting syntax is slightly different. Building on the previous example where a level is defined as an array of enums indexed by yet another enum, we can add the following lines to add a light tower type subdivided into height levels accessed through their integer index:</p>
    734. 

  734. <p><pre class="listing"><span class="Keyword">type</span>
    735. 

  735.   <span class="Identifier">LightTower</span> <span class="Operator">=</span> <span class="Identifier">array</span><span class="Punctuation">[</span><span class="FloatNumber">1.</span><span class="Operator">.</span><span class="DecNumber">10</span><span class="Punctuation">,</span> <span class="Identifier">LevelSetting</span><span class="Punctuation">]</span>
    736. 

  736. <span class="Keyword">var</span>
    737. 

  737.   <span class="Identifier">tower</span><span class="Punctuation">:</span> <span class="Identifier">LightTower</span>
    738. 

  738. <span class="Identifier">tower</span><span class="Punctuation">[</span><span class="DecNumber">1</span><span class="Punctuation">]</span><span class="Punctuation">[</span><span class="Identifier">north</span><span class="Punctuation">]</span> <span class="Operator">=</span> <span class="Identifier">slowBlink</span>
    739. 

  739. <span class="Identifier">tower</span><span class="Punctuation">[</span><span class="DecNumber">1</span><span class="Punctuation">]</span><span class="Punctuation">[</span><span class="Identifier">east</span><span class="Punctuation">]</span> <span class="Operator">=</span> <span class="Identifier">mediumBlink</span>
    740. 

  740. <span class="Identifier">echo</span> <span class="Identifier">len</span><span class="Punctuation">(</span><span class="Identifier">tower</span><span class="Punctuation">)</span>     <span class="Comment"># --&gt; 10</span>
    741. 

  741. <span class="Identifier">echo</span> <span class="Identifier">len</span><span class="Punctuation">(</span><span class="Identifier">tower</span><span class="Punctuation">[</span><span class="DecNumber">1</span><span class="Punctuation">]</span><span class="Punctuation">)</span>  <span class="Comment"># --&gt; 4</span>
    742. 

  742. <span class="Identifier">echo</span> <span class="Identifier">tower</span>          <span class="Comment"># --&gt; [[slowBlink, mediumBlink, ...more output..</span>
    743. 

  743. <span class="Comment"># The following lines don't compile due to type mismatch errors</span>
    744. 

  744. <span class="Comment">#tower[north][east] = on</span>
    745. 

  745. <span class="Comment">#tower[0][1] = on</span></pre></p>
    746. 

  746. <p>Note how the built-in <tt class="docutils literal"><span class="pre"><span class="Identifier">len</span></span></tt> proc returns only the array's first dimension length.  Another way of defining the <tt class="docutils literal"><span class="pre"><span class="Identifier">LightTower</span></span></tt> to better illustrate its nested nature would be to omit the previous definition of the <tt class="docutils literal"><span class="pre"><span class="Identifier">LevelSetting</span></span></tt> type and instead write it embedded directly as the type of the first dimension:</p>
    747. 

  747. <p><pre class="listing"><span class="Keyword">type</span>
    748. 

  748.   <span class="Identifier">LightTower</span> <span class="Operator">=</span> <span class="Identifier">array</span><span class="Punctuation">[</span><span class="FloatNumber">1.</span><span class="Operator">.</span><span class="DecNumber">10</span><span class="Punctuation">,</span> <span class="Identifier">array</span><span class="Punctuation">[</span><span class="Identifier">north</span><span class="Operator">..</span><span class="Identifier">west</span><span class="Punctuation">,</span> <span class="Identifier">BlinkLights</span><span class="Punctuation">]</span><span class="Punctuation">]</span></pre></p>
    749. 

  749. <p>It is quite common to have arrays start at zero, so there's a shortcut syntax to specify a range from zero to the specified index minus one:</p>
    750. 

  750. <p><pre class="listing"><span class="Keyword">type</span>
    751. 

  751.   <span class="Identifier">IntArray</span> <span class="Operator">=</span> <span class="Identifier">array</span><span class="Punctuation">[</span><span class="FloatNumber">0.</span><span class="Operator">.</span><span class="DecNumber">5</span><span class="Punctuation">,</span> <span class="Identifier">int</span><span class="Punctuation">]</span> <span class="Comment"># an array that is indexed with 0..5</span>
    752. 

  752.   <span class="Identifier">QuickArray</span> <span class="Operator">=</span> <span class="Identifier">array</span><span class="Punctuation">[</span><span class="DecNumber">6</span><span class="Punctuation">,</span> <span class="Identifier">int</span><span class="Punctuation">]</span>  <span class="Comment"># an array that is indexed with 0..5</span>
    753. 

  753. <span class="Keyword">var</span>
    754. 

  754.   <span class="Identifier">x</span><span class="Punctuation">:</span> <span class="Identifier">IntArray</span>
    755. 

  755.   <span class="Identifier">y</span><span class="Punctuation">:</span> <span class="Identifier">QuickArray</span>
    756. 

  756. <span class="Identifier">x</span> <span class="Operator">=</span> <span class="Punctuation">[</span><span class="DecNumber">1</span><span class="Punctuation">,</span> <span class="DecNumber">2</span><span class="Punctuation">,</span> <span class="DecNumber">3</span><span class="Punctuation">,</span> <span class="DecNumber">4</span><span class="Punctuation">,</span> <span class="DecNumber">5</span><span class="Punctuation">,</span> <span class="DecNumber">6</span><span class="Punctuation">]</span>
    757. 

  757. <span class="Identifier">y</span> <span class="Operator">=</span> <span class="Identifier">x</span>
    758. 

  758. <span class="Keyword">for</span> <span class="Identifier">i</span> <span class="Keyword">in</span> <span class="Identifier">low</span><span class="Punctuation">(</span><span class="Identifier">x</span><span class="Punctuation">)</span> <span class="Operator">..</span> <span class="Identifier">high</span><span class="Punctuation">(</span><span class="Identifier">x</span><span class="Punctuation">)</span><span class="Punctuation">:</span>
    759. 

  759.   <span class="Identifier">echo</span> <span class="Identifier">x</span><span class="Punctuation">[</span><span class="Identifier">i</span><span class="Punctuation">]</span><span class="Punctuation">,</span> <span class="Identifier">y</span><span class="Punctuation">[</span><span class="Identifier">i</span><span class="Punctuation">]</span></pre></p>
    760. 

  760. 

  761. <h2><a class="toc-backref" id="advanced-types-sequences" href="#advanced-types-sequences">Sequences</a></h2><p>Sequences are similar to arrays but of dynamic length which may change during runtime (like strings). Since sequences are resizable they are always allocated on the heap and garbage collected.</p>
    762. 

  762. <p>Sequences are always indexed with an <tt class="docutils literal"><span class="pre"><span class="Identifier">int</span></span></tt> starting at position 0.  The <a class="reference external" href=" system.html#len,seq[T]">len</a>, <a class="reference external" href="system.html#low,openArray[T]">low</a> and <a class="reference external" href=" system.html#high,openArray[T]">high</a> operations are available for sequences too. The notation <tt class="docutils literal"><span class="pre"><span class="Identifier">x</span><span class="Punctuation">[</span><span class="Identifier">i</span><span class="Punctuation">]</span></span></tt> can be used to access the i-th element of <tt class="docutils literal"><span class="pre"><span class="Identifier">x</span></span></tt>.</p>
    763. 

  763. <p>Sequences can be constructed by the array constructor <tt class="docutils literal"><span class="pre"><span class="Punctuation">[</span><span class="Punctuation">]</span></span></tt> in conjunction with the array to sequence operator <tt class="docutils literal"><span class="pre"><span class="Operator">@</span></span></tt>. Another way to allocate space for a sequence is to call the built-in <a class="reference external" href="system.html#newSeq">newSeq</a> procedure.</p>
    764. 

  764. <p>A sequence may be passed to an openarray parameter.</p>
    765. 

  765. <p>Example:</p>
    766. 

  766. <p><pre class="listing"><span class="Keyword">var</span>
    767. 

  767.   <span class="Identifier">x</span><span class="Punctuation">:</span> <span class="Identifier">seq</span><span class="Punctuation">[</span><span class="Identifier">int</span><span class="Punctuation">]</span> <span class="Comment"># a reference to a sequence of integers</span>
    768. 

  768. <span class="Identifier">x</span> <span class="Operator">=</span> <span class="Operator">@</span><span class="Punctuation">[</span><span class="DecNumber">1</span><span class="Punctuation">,</span> <span class="DecNumber">2</span><span class="Punctuation">,</span> <span class="DecNumber">3</span><span class="Punctuation">,</span> <span class="DecNumber">4</span><span class="Punctuation">,</span> <span class="DecNumber">5</span><span class="Punctuation">,</span> <span class="DecNumber">6</span><span class="Punctuation">]</span> <span class="Comment"># the @ turns the array into a sequence allocated on the heap</span></pre></p>
    769. 

  769. <p>Sequence variables are initialized with <tt class="docutils literal"><span class="pre"><span class="Operator">@</span><span class="Punctuation">[</span><span class="Punctuation">]</span></span></tt>.</p>
    770. 

  770. <p>The <tt class="docutils literal"><span class="pre"><span class="Keyword">for</span></span></tt> statement can be used with one or two variables when used with a sequence. When you use the one variable form, the variable will hold the value provided by the sequence. The <tt class="docutils literal"><span class="pre"><span class="Keyword">for</span></span></tt> statement is looping over the results from the <a class="reference external" href="iterators.html#items.i,seq[T]">items()</a> iterator from the <a class="reference external" href=" system.html">system</a> module.  But if you use the two-variable form, the first variable will hold the index position and the second variable will hold the value. Here the <tt class="docutils literal"><span class="pre"><span class="Keyword">for</span></span></tt> statement is looping over the results from the <a class="reference external" href="iterators.html#pairs.i,seq[T]">pairs()</a> iterator from the <a class="reference external" href=" system.html">system</a> module.  Examples:</p>
    771. 

  771. <p><pre class="listing"><span class="Keyword">for</span> <span class="Identifier">value</span> <span class="Keyword">in</span> <span class="Operator">@</span><span class="Punctuation">[</span><span class="DecNumber">3</span><span class="Punctuation">,</span> <span class="DecNumber">4</span><span class="Punctuation">,</span> <span class="DecNumber">5</span><span class="Punctuation">]</span><span class="Punctuation">:</span>
    772. 

  772.   <span class="Identifier">echo</span> <span class="Identifier">value</span>
    773. 

  773. <span class="Comment"># --&gt; 3</span>
    774. 

  774. <span class="Comment"># --&gt; 4</span>
    775. 

  775. <span class="Comment"># --&gt; 5</span>
    776. 

  776. 

  777. <span class="Keyword">for</span> <span class="Identifier">i</span><span class="Punctuation">,</span> <span class="Identifier">value</span> <span class="Keyword">in</span> <span class="Operator">@</span><span class="Punctuation">[</span><span class="DecNumber">3</span><span class="Punctuation">,</span> <span class="DecNumber">4</span><span class="Punctuation">,</span> <span class="DecNumber">5</span><span class="Punctuation">]</span><span class="Punctuation">:</span>
    778. 

  778.   <span class="Identifier">echo</span> <span class="StringLit">&quot;index: &quot;</span><span class="Punctuation">,</span> <span class="Operator">$</span><span class="Identifier">i</span><span class="Punctuation">,</span> <span class="StringLit">&quot;, value:&quot;</span><span class="Punctuation">,</span> <span class="Operator">$</span><span class="Identifier">value</span>
    779. 

  779. <span class="Comment"># --&gt; index: 0, value:3</span>
    780. 

  780. <span class="Comment"># --&gt; index: 1, value:4</span>
    781. 

  781. <span class="Comment"># --&gt; index: 2, value:5</span></pre></p>
    782. 

  782. 

  783. <h2><a class="toc-backref" id="advanced-types-open-arrays" href="#advanced-types-open-arrays">Open arrays</a></h2><p><strong>Note</strong>: Openarrays can only be used for parameters.</p>
    784. 

  784. <p>Often fixed-size arrays turn out to be too inflexible; procedures should be able to deal with arrays of different sizes. The <span id="openarray_1">openarray</span> type allows this. Openarrays are always indexed with an <tt class="docutils literal"><span class="pre"><span class="Identifier">int</span></span></tt> starting at position 0. The <a class="reference external" href="system.html#len,TOpenArray">len</a>, <a class="reference external" href="system.html#low,openArray[T]">low</a> and <a class="reference external" href="system.html#high,openArray[T]">high</a> operations are available for open arrays too.  Any array with a compatible base type can be passed to an openarray parameter, the index type does not matter.</p>
    785. 

  785. <p><pre class="listing"><span class="Keyword">var</span>
    786. 

  786.   <span class="Identifier">fruits</span><span class="Punctuation">:</span>   <span class="Identifier">seq</span><span class="Punctuation">[</span><span class="Identifier">string</span><span class="Punctuation">]</span>       <span class="Comment"># reference to a sequence of strings that is initialized with '@[]'</span>
    787. 

  787.   <span class="Identifier">capitals</span><span class="Punctuation">:</span> <span class="Identifier">array</span><span class="Punctuation">[</span><span class="DecNumber">3</span><span class="Punctuation">,</span> <span class="Identifier">string</span><span class="Punctuation">]</span>  <span class="Comment"># array of strings with a fixed size</span>
    788. 

  788. 

  789. <span class="Identifier">capitals</span> <span class="Operator">=</span> <span class="Punctuation">[</span><span class="StringLit">&quot;New York&quot;</span><span class="Punctuation">,</span> <span class="StringLit">&quot;London&quot;</span><span class="Punctuation">,</span> <span class="StringLit">&quot;Berlin&quot;</span><span class="Punctuation">]</span>   <span class="Comment"># array 'capitals' allows assignment of only three elements</span>
    790. 

  790. <span class="Identifier">fruits</span><span class="Operator">.</span><span class="Identifier">add</span><span class="Punctuation">(</span><span class="StringLit">&quot;Banana&quot;</span><span class="Punctuation">)</span>          <span class="Comment"># sequence 'fruits' is dynamically expandable during runtime</span>
    791. 

  791. <span class="Identifier">fruits</span><span class="Operator">.</span><span class="Identifier">add</span><span class="Punctuation">(</span><span class="StringLit">&quot;Mango&quot;</span><span class="Punctuation">)</span>
    792. 

  792. 

  793. <span class="Keyword">proc</span> <span class="Identifier">openArraySize</span><span class="Punctuation">(</span><span class="Identifier">oa</span><span class="Punctuation">:</span> <span class="Identifier">openArray</span><span class="Punctuation">[</span><span class="Identifier">string</span><span class="Punctuation">]</span><span class="Punctuation">)</span><span class="Punctuation">:</span> <span class="Identifier">int</span> <span class="Operator">=</span>
    794. 

  794.   <span class="Identifier">oa</span><span class="Operator">.</span><span class="Identifier">len</span>
    795. 

  795. 

  796. <span class="Identifier">assert</span> <span class="Identifier">openArraySize</span><span class="Punctuation">(</span><span class="Identifier">fruits</span><span class="Punctuation">)</span> <span class="Operator">==</span> <span class="DecNumber">2</span>     <span class="Comment"># procedure accepts a sequence as parameter</span>
    797. 

  797. <span class="Identifier">assert</span> <span class="Identifier">openArraySize</span><span class="Punctuation">(</span><span class="Identifier">capitals</span><span class="Punctuation">)</span> <span class="Operator">==</span> <span class="DecNumber">3</span>   <span class="Comment"># but also an array type</span></pre></p>
    798. 

  798. <p>The openarray type cannot be nested: multidimensional openarrays are not supported because this is seldom needed and cannot be done efficiently.</p>
    799. 

  799. 

  800. <h2><a class="toc-backref" id="advanced-types-varargs" href="#advanced-types-varargs">Varargs</a></h2><p>A <tt class="docutils literal"><span class="pre"><span class="Identifier">varargs</span></span></tt> parameter is like an openarray parameter. However, it is also a means to implement passing a variable number of arguments to a procedure. The compiler converts the list of arguments to an array automatically:</p>
    801. 

  801. <p><pre class="listing"><span class="Keyword">proc</span> <span class="Identifier">myWriteln</span><span class="Punctuation">(</span><span class="Identifier">f</span><span class="Punctuation">:</span> <span class="Identifier">File</span><span class="Punctuation">,</span> <span class="Identifier">a</span><span class="Punctuation">:</span> <span class="Identifier">varargs</span><span class="Punctuation">[</span><span class="Identifier">string</span><span class="Punctuation">]</span><span class="Punctuation">)</span> <span class="Operator">=</span>
    802. 

  802.   <span class="Keyword">for</span> <span class="Identifier">s</span> <span class="Keyword">in</span> <span class="Identifier">items</span><span class="Punctuation">(</span><span class="Identifier">a</span><span class="Punctuation">)</span><span class="Punctuation">:</span>
    803. 

  803.     <span class="Identifier">write</span><span class="Punctuation">(</span><span class="Identifier">f</span><span class="Punctuation">,</span> <span class="Identifier">s</span><span class="Punctuation">)</span>
    804. 

  804.   <span class="Identifier">write</span><span class="Punctuation">(</span><span class="Identifier">f</span><span class="Punctuation">,</span> <span class="StringLit">&quot;</span><span class="EscapeSequence">\n</span><span class="StringLit">&quot;</span><span class="Punctuation">)</span>
    805. 

  805. 

  806. <span class="Identifier">myWriteln</span><span class="Punctuation">(</span><span class="Identifier">stdout</span><span class="Punctuation">,</span> <span class="StringLit">&quot;abc&quot;</span><span class="Punctuation">,</span> <span class="StringLit">&quot;def&quot;</span><span class="Punctuation">,</span> <span class="StringLit">&quot;xyz&quot;</span><span class="Punctuation">)</span>
    807. 

  807. <span class="Comment"># is transformed by the compiler to:</span>
    808. 

  808. <span class="Identifier">myWriteln</span><span class="Punctuation">(</span><span class="Identifier">stdout</span><span class="Punctuation">,</span> <span class="Punctuation">[</span><span class="StringLit">&quot;abc&quot;</span><span class="Punctuation">,</span> <span class="StringLit">&quot;def&quot;</span><span class="Punctuation">,</span> <span class="StringLit">&quot;xyz&quot;</span><span class="Punctuation">]</span><span class="Punctuation">)</span></pre></p>
    809. 

  809. <p>This transformation is only done if the varargs parameter is the last parameter in the procedure header. It is also possible to perform type conversions in this context:</p>
    810. 

  810. <p><pre class="listing"><span class="Keyword">proc</span> <span class="Identifier">myWriteln</span><span class="Punctuation">(</span><span class="Identifier">f</span><span class="Punctuation">:</span> <span class="Identifier">File</span><span class="Punctuation">,</span> <span class="Identifier">a</span><span class="Punctuation">:</span> <span class="Identifier">varargs</span><span class="Punctuation">[</span><span class="Identifier">string</span><span class="Punctuation">,</span> <span class="Punctuation">`</span><span class="Operator">$</span><span class="Punctuation">`</span><span class="Punctuation">]</span><span class="Punctuation">)</span> <span class="Operator">=</span>
    811. 

  811.   <span class="Keyword">for</span> <span class="Identifier">s</span> <span class="Keyword">in</span> <span class="Identifier">items</span><span class="Punctuation">(</span><span class="Identifier">a</span><span class="Punctuation">)</span><span class="Punctuation">:</span>
    812. 

  812.     <span class="Identifier">write</span><span class="Punctuation">(</span><span class="Identifier">f</span><span class="Punctuation">,</span> <span class="Identifier">s</span><span class="Punctuation">)</span>
    813. 

  813.   <span class="Identifier">write</span><span class="Punctuation">(</span><span class="Identifier">f</span><span class="Punctuation">,</span> <span class="StringLit">&quot;</span><span class="EscapeSequence">\n</span><span class="StringLit">&quot;</span><span class="Punctuation">)</span>
    814. 

  814. 

  815. <span class="Identifier">myWriteln</span><span class="Punctuation">(</span><span class="Identifier">stdout</span><span class="Punctuation">,</span> <span class="DecNumber">123</span><span class="Punctuation">,</span> <span class="StringLit">&quot;abc&quot;</span><span class="Punctuation">,</span> <span class="FloatNumber">4.0</span><span class="Punctuation">)</span>
    816. 

  816. <span class="Comment"># is transformed by the compiler to:</span>
    817. 

  817. <span class="Identifier">myWriteln</span><span class="Punctuation">(</span><span class="Identifier">stdout</span><span class="Punctuation">,</span> <span class="Punctuation">[</span><span class="Operator">$</span><span class="DecNumber">123</span><span class="Punctuation">,</span> <span class="Operator">$</span><span class="StringLit">&quot;abc&quot;</span><span class="Punctuation">,</span> <span class="Operator">$</span><span class="FloatNumber">4.0</span><span class="Punctuation">]</span><span class="Punctuation">)</span></pre></p>
    818. 

  818. <p>In this example <a class="reference external" href="dollars.html">$</a> is applied to any argument that is passed to the parameter <tt class="docutils literal"><span class="pre"><span class="Identifier">a</span></span></tt>. Note that <a class="reference external" href="dollars.html">$</a> applied to strings is a nop.</p>
    819. 

  819. 

  820. <h2><a class="toc-backref" id="advanced-types-slices" href="#advanced-types-slices">Slices</a></h2><p>Slices look similar to subranges types in syntax but are used in a different context. A slice is just an object of type Slice which contains two bounds, <tt class="docutils literal"><span class="pre"><span class="Identifier">a</span></span></tt> and <tt class="docutils literal"><span class="pre"><span class="Identifier">b</span></span></tt>. By itself a slice is not very useful, but other collection types define operators which accept Slice objects to define ranges.</p>
    821. 

  821. <p><pre class="listing"><span class="Keyword">var</span>
    822. 

  822.   <span class="Identifier">a</span> <span class="Operator">=</span> <span class="StringLit">&quot;Nim is a programming language&quot;</span>
    823. 

  823.   <span class="Identifier">b</span> <span class="Operator">=</span> <span class="StringLit">&quot;Slices are useless.&quot;</span>
    824. 

  824. 

  825. <span class="Identifier">echo</span> <span class="Identifier">a</span><span class="Punctuation">[</span><span class="DecNumber">7</span> <span class="Operator">..</span> <span class="DecNumber">12</span><span class="Punctuation">]</span> <span class="Comment"># --&gt; 'a prog'</span>
    826. 

  826. <span class="Identifier">b</span><span class="Punctuation">[</span><span class="DecNumber">11</span> <span class="Operator">..</span> <span class="Operator">^</span><span class="DecNumber">2</span><span class="Punctuation">]</span> <span class="Operator">=</span> <span class="StringLit">&quot;useful&quot;</span>
    827. 

  827. <span class="Identifier">echo</span> <span class="Identifier">b</span> <span class="Comment"># --&gt; 'Slices are useful.'</span></pre></p>
    828. 

  828. <p>In the previous example slices are used to modify a part of a string. The slice's bounds can hold any value supported by their type, but it is the proc using the slice object which defines what values are accepted.</p>
    829. 

  829. <p>To understand the different ways of specifying the indices of strings, arrays, sequences, etc., it must be remembered that Nim uses zero-based indices.</p>
    830. 

  830. <p>So the string <tt class="docutils literal"><span class="pre"><span class="Identifier">b</span></span></tt> is of length 19, and two different ways of specifying the indices are</p>
    831. 

  831. <p><pre class="listing"><span class="StringLit">&quot;Slices are useless.&quot;</span>
    832. 

  832.  <span class="Operator">|</span>          <span class="Operator">|</span>     <span class="Operator">|</span>
    833. 

  833.  <span class="DecNumber">0</span>         <span class="DecNumber">11</span>    <span class="DecNumber">17</span>   <span class="Keyword">using</span> <span class="Identifier">indices</span>
    834. 

  834. <span class="Operator">^</span><span class="DecNumber">19</span>        <span class="Operator">^</span><span class="DecNumber">8</span>    <span class="Operator">^</span><span class="DecNumber">2</span>   <span class="Keyword">using</span> <span class="Operator">^</span> <span class="Identifier">syntax</span></pre></p>
    835. 

  835. <p>where <tt class="docutils literal"><span class="pre"><span class="Identifier">b</span><span class="Punctuation">[</span><span class="DecNumber">0</span> <span class="Operator">..</span> <span class="Operator">^</span><span class="DecNumber">1</span><span class="Punctuation">]</span></span></tt> is equivalent to <tt class="docutils literal"><span class="pre"><span class="Identifier">b</span><span class="Punctuation">[</span><span class="DecNumber">0</span> <span class="Operator">..</span> <span class="Identifier">b</span><span class="Operator">.</span><span class="Identifier">len</span><span class="Operator">-</span><span class="DecNumber">1</span><span class="Punctuation">]</span></span></tt> and <tt class="docutils literal"><span class="pre"><span class="Identifier">b</span><span class="Punctuation">[</span><span class="DecNumber">0</span> <span class="Operator">..&lt;</span> <span class="Identifier">b</span><span class="Operator">.</span><span class="Identifier">len</span><span class="Punctuation">]</span></span></tt>, and it can be seen that the <tt class="docutils literal"><span class="pre"><span class="Operator">^</span><span class="DecNumber">1</span></span></tt> provides a shorthand way of specifying the <tt class="docutils literal"><span class="pre"><span class="Identifier">b</span><span class="Operator">.</span><span class="Identifier">len</span><span class="Operator">-</span><span class="DecNumber">1</span></span></tt>. See the <a class="reference external" href="system.html#^.t%2Cint">backwards index operator</a>.</p>
    836. 

  836. <p>In the above example, because the string ends in a period, to get the portion of the string that is &quot;useless&quot; and replace it with &quot;useful&quot;.</p>
    837. 

  837. <p><tt class="docutils literal"><span class="pre"><span class="Identifier">b</span><span class="Punctuation">[</span><span class="DecNumber">11</span> <span class="Operator">..</span> <span class="Operator">^</span><span class="DecNumber">2</span><span class="Punctuation">]</span></span></tt> is the portion &quot;useless&quot;, and <tt class="docutils literal"><span class="pre"><span class="Identifier">b</span><span class="Punctuation">[</span><span class="DecNumber">11</span> <span class="Operator">..</span> <span class="Operator">^</span><span class="DecNumber">2</span><span class="Punctuation">]</span> <span class="Operator">=</span> <span class="StringLit">&quot;useful&quot;</span></span></tt> replaces the &quot;useless&quot; portion with &quot;useful&quot;, giving the result &quot;Slices are useful.&quot;</p>
    838. 

  838. <p>Note 1: alternate ways of writing this are <tt class="docutils literal"><span class="pre"><span class="Identifier">b</span><span class="Punctuation">[</span><span class="Operator">^</span><span class="DecNumber">8</span> <span class="Operator">..</span> <span class="Operator">^</span><span class="DecNumber">2</span><span class="Punctuation">]</span> <span class="Operator">=</span> <span class="StringLit">&quot;useful&quot;</span></span></tt> or as <tt class="docutils literal"><span class="pre"><span class="Identifier">b</span><span class="Punctuation">[</span><span class="DecNumber">11</span> <span class="Operator">..</span> <span class="Identifier">b</span><span class="Operator">.</span><span class="Identifier">len</span><span class="Operator">-</span><span class="DecNumber">2</span><span class="Punctuation">]</span> <span class="Operator">=</span> <span class="StringLit">&quot;useful&quot;</span></span></tt> or as <tt class="docutils literal"><span class="pre"><span class="Identifier">b</span><span class="Punctuation">[</span><span class="DecNumber">11</span> <span class="Operator">..&lt;</span> <span class="Identifier">b</span><span class="Operator">.</span><span class="Identifier">len</span><span class="Operator">-</span><span class="DecNumber">1</span><span class="Punctuation">]</span> <span class="Operator">=</span> <span class="StringLit">&quot;useful&quot;</span></span></tt>.</p>
    839. 

  839. <p>Note 2: As the <tt class="docutils literal"><span class="pre"><span class="Operator">^</span></span></tt> template returns a <a class="reference external" href="manual.html#types-distinct-type">distinct int</a> of type <tt class="docutils literal"><span class="pre"><span class="Identifier">BackwardsIndex</span></span></tt>, we can have a <tt class="docutils literal"><span class="pre"><span class="Identifier">lastIndex</span></span></tt> constant defined as <tt class="docutils literal"><span class="pre"><span class="Keyword">const</span> <span class="Identifier">lastIndex</span> <span class="Operator">=</span> <span class="Operator">^</span><span class="DecNumber">1</span></span></tt>, and later used as <tt class="docutils literal"><span class="pre"><span class="Identifier">b</span><span class="Punctuation">[</span><span class="DecNumber">0</span> <span class="Operator">..</span> <span class="Identifier">lastIndex</span><span class="Punctuation">]</span></span></tt>.</p>
    840. 

  840. 

  841. <h2><a class="toc-backref" id="advanced-types-objects" href="#advanced-types-objects">Objects</a></h2><p>The default type to pack different values together in a single structure with a name is the object type. An object is a value type, which means that when an object is assigned to a new variable all its components are copied as well.</p>
    842. 

  842. <p>Each object type <tt class="docutils literal"><span class="pre"><span class="Identifier">Foo</span></span></tt> has a constructor <tt class="docutils literal"><span class="pre"><span class="Identifier">Foo</span><span class="Punctuation">(</span><span class="Identifier">field</span><span class="Punctuation">:</span> <span class="Identifier">value</span><span class="Punctuation">,</span> <span class="Operator">...</span><span class="Punctuation">)</span></span></tt> where all of its fields can be initialized. Unspecified fields will get their default value.</p>
    843. 

  843. <p><pre class="listing"><span class="Keyword">type</span>
    844. 

  844.   <span class="Identifier">Person</span> <span class="Operator">=</span> <span class="Keyword">object</span>
    845. 

  845.     <span class="Identifier">name</span><span class="Punctuation">:</span> <span class="Identifier">string</span>
    846. 

  846.     <span class="Identifier">age</span><span class="Punctuation">:</span> <span class="Identifier">int</span>
    847. 

  847. 

  848. <span class="Keyword">var</span> <span class="Identifier">person1</span> <span class="Operator">=</span> <span class="Identifier">Person</span><span class="Punctuation">(</span><span class="Identifier">name</span><span class="Punctuation">:</span> <span class="StringLit">&quot;Peter&quot;</span><span class="Punctuation">,</span> <span class="Identifier">age</span><span class="Punctuation">:</span> <span class="DecNumber">30</span><span class="Punctuation">)</span>
    849. 

  849. 

  850. <span class="Identifier">echo</span> <span class="Identifier">person1</span><span class="Operator">.</span><span class="Identifier">name</span> <span class="Comment"># &quot;Peter&quot;</span>
    851. 

  851. <span class="Identifier">echo</span> <span class="Identifier">person1</span><span class="Operator">.</span><span class="Identifier">age</span>  <span class="Comment"># 30</span>
    852. 

  852. 

  853. <span class="Keyword">var</span> <span class="Identifier">person2</span> <span class="Operator">=</span> <span class="Identifier">person1</span> <span class="Comment"># copy of person 1</span>
    854. 

  854. 

  855. <span class="Identifier">person2</span><span class="Operator">.</span><span class="Identifier">age</span> <span class="Operator">+=</span> <span class="DecNumber">14</span>
    856. 

  856. 

  857. <span class="Identifier">echo</span> <span class="Identifier">person1</span><span class="Operator">.</span><span class="Identifier">age</span> <span class="Comment"># 30</span>
    858. 

  858. <span class="Identifier">echo</span> <span class="Identifier">person2</span><span class="Operator">.</span><span class="Identifier">age</span> <span class="Comment"># 44</span>
    859. 

  859. 

  860. 

  861. <span class="Comment"># the order may be changed</span>
    862. 

  862. <span class="Keyword">let</span> <span class="Identifier">person3</span> <span class="Operator">=</span> <span class="Identifier">Person</span><span class="Punctuation">(</span><span class="Identifier">age</span><span class="Punctuation">:</span> <span class="DecNumber">12</span><span class="Punctuation">,</span> <span class="Identifier">name</span><span class="Punctuation">:</span> <span class="StringLit">&quot;Quentin&quot;</span><span class="Punctuation">)</span>
    863. 

  863. 

  864. <span class="Comment"># not every member needs to be specified</span>
    865. 

  865. <span class="Keyword">let</span> <span class="Identifier">person4</span> <span class="Operator">=</span> <span class="Identifier">Person</span><span class="Punctuation">(</span><span class="Identifier">age</span><span class="Punctuation">:</span> <span class="DecNumber">3</span><span class="Punctuation">)</span>
    866. 

  866. <span class="Comment"># unspecified members will be initialized with their default</span>
    867. 

  867. <span class="Comment"># values. In this case it is the empty string.</span>
    868. 

  868. <span class="Identifier">doAssert</span> <span class="Identifier">person4</span><span class="Operator">.</span><span class="Identifier">name</span> <span class="Operator">==</span> <span class="StringLit">&quot;&quot;</span></pre></p>
    869. 

  869. <p>Object fields that should be visible from outside the defining module have to be marked with <tt class="docutils literal"><span class="pre"><span class="Operator">*</span></span></tt>.</p>
    870. 

  870. <p><pre class="listing"><span class="Keyword">type</span>
    871. 

  871.   <span class="Identifier">Person</span><span class="Operator">*</span> <span class="Operator">=</span> <span class="Keyword">object</span> <span class="Comment"># the type is visible from other modules</span>
    872. 

  872.     <span class="Identifier">name</span><span class="Operator">*:</span> <span class="Identifier">string</span>  <span class="Comment"># the field of this type is visible from other modules</span>
    873. 

  873.     <span class="Identifier">age</span><span class="Operator">*:</span> <span class="Identifier">int</span></pre></p>
    874. 

  874. 

  875. <h2><a class="toc-backref" id="advanced-types-tuples" href="#advanced-types-tuples">Tuples</a></h2><p>Tuples are very much like what you have seen so far from objects. They are value types where the assignment operator copies each component. Unlike object types though, tuple types are structurally typed, meaning different tuple-types are <em>equivalent</em> if they specify fields of the same type and of the same name in the same order.</p>
    876. 

  876. <p>The constructor <tt class="docutils literal"><span class="pre"><span class="Punctuation">(</span><span class="Punctuation">)</span></span></tt> can be used to construct tuples. The order of the fields in the constructor must match the order in the tuple's definition. But unlike objects, a name for the tuple type may not be used here.</p>
    877. 

  877. <p>Like the object type the notation <tt class="docutils literal"><span class="pre"><span class="Identifier">t</span><span class="Operator">.</span><span class="Identifier">field</span></span></tt> is used to access a tuple's field. Another notation that is not available for objects is <tt class="docutils literal"><span class="pre"><span class="Identifier">t</span><span class="Punctuation">[</span><span class="Identifier">i</span><span class="Punctuation">]</span></span></tt> to access the <tt class="docutils literal"><span class="pre"><span class="Identifier">i</span></span></tt>'th field. Here <tt class="docutils literal"><span class="pre"><span class="Identifier">i</span></span></tt> must be a constant integer.</p>
    878. 

  878. <p><pre class="listing"><span class="Keyword">type</span>
    879. 

  879.   <span class="Comment"># type representing a person:</span>
    880. 

  880.   <span class="Comment"># A person consists of a name and an age.</span>
    881. 

  881.   <span class="Identifier">Person</span> <span class="Operator">=</span> <span class="Keyword">tuple</span>
    882. 

  882.     <span class="Identifier">name</span><span class="Punctuation">:</span> <span class="Identifier">string</span>
    883. 

  883.     <span class="Identifier">age</span><span class="Punctuation">:</span> <span class="Identifier">int</span>
    884. 

  884.   
    885. 

  885.   <span class="Comment"># Alternative syntax for an equivalent type.</span>
    886. 

  886.   <span class="Identifier">PersonX</span> <span class="Operator">=</span> <span class="Keyword">tuple</span><span class="Punctuation">[</span><span class="Identifier">name</span><span class="Punctuation">:</span> <span class="Identifier">string</span><span class="Punctuation">,</span> <span class="Identifier">age</span><span class="Punctuation">:</span> <span class="Identifier">int</span><span class="Punctuation">]</span>
    887. 

  887.   
    888. 

  888.   <span class="Comment"># anonymous field syntax</span>
    889. 

  889.   <span class="Identifier">PersonY</span> <span class="Operator">=</span> <span class="Punctuation">(</span><span class="Identifier">string</span><span class="Punctuation">,</span> <span class="Identifier">int</span><span class="Punctuation">)</span>
    890. 

  890. 

  891. <span class="Keyword">var</span>
    892. 

  892.   <span class="Identifier">person</span><span class="Punctuation">:</span> <span class="Identifier">Person</span>
    893. 

  893.   <span class="Identifier">personX</span><span class="Punctuation">:</span> <span class="Identifier">PersonX</span>
    894. 

  894.   <span class="Identifier">personY</span><span class="Punctuation">:</span> <span class="Identifier">PersonY</span>
    895. 

  895. 

  896. <span class="Identifier">person</span> <span class="Operator">=</span> <span class="Punctuation">(</span><span class="Identifier">name</span><span class="Punctuation">:</span> <span class="StringLit">&quot;Peter&quot;</span><span class="Punctuation">,</span> <span class="Identifier">age</span><span class="Punctuation">:</span> <span class="DecNumber">30</span><span class="Punctuation">)</span>
    897. 

  897. <span class="Comment"># Person and PersonX are equivalent</span>
    898. 

  898. <span class="Identifier">personX</span> <span class="Operator">=</span> <span class="Identifier">person</span>
    899. 

  899. 

  900. <span class="Comment"># Create a tuple with anonymous fields:</span>
    901. 

  901. <span class="Identifier">personY</span> <span class="Operator">=</span> <span class="Punctuation">(</span><span class="StringLit">&quot;Peter&quot;</span><span class="Punctuation">,</span> <span class="DecNumber">30</span><span class="Punctuation">)</span>
    902. 

  902. 

  903. <span class="Comment"># A tuple with anonymous fields is compatible with a tuple that has</span>
    904. 

  904. <span class="Comment"># field names.</span>
    905. 

  905. <span class="Identifier">person</span> <span class="Operator">=</span> <span class="Identifier">personY</span>
    906. 

  906. <span class="Identifier">personY</span> <span class="Operator">=</span> <span class="Identifier">person</span>
    907. 

  907. 

  908. <span class="Comment"># Usually used for short tuple initialization syntax</span>
    909. 

  909. <span class="Identifier">person</span> <span class="Operator">=</span> <span class="Punctuation">(</span><span class="StringLit">&quot;Peter&quot;</span><span class="Punctuation">,</span> <span class="DecNumber">30</span><span class="Punctuation">)</span>
    910. 

  910. 

  911. <span class="Identifier">echo</span> <span class="Identifier">person</span><span class="Operator">.</span><span class="Identifier">name</span> <span class="Comment"># &quot;Peter&quot;</span>
    912. 

  912. <span class="Identifier">echo</span> <span class="Identifier">person</span><span class="Operator">.</span><span class="Identifier">age</span>  <span class="Comment"># 30</span>
    913. 

  913. 

  914. <span class="Identifier">echo</span> <span class="Identifier">person</span><span class="Punctuation">[</span><span class="DecNumber">0</span><span class="Punctuation">]</span> <span class="Comment"># &quot;Peter&quot;</span>
    915. 

  915. <span class="Identifier">echo</span> <span class="Identifier">person</span><span class="Punctuation">[</span><span class="DecNumber">1</span><span class="Punctuation">]</span> <span class="Comment"># 30</span>
    916. 

  916. 

  917. <span class="Comment"># You don't need to declare tuples in a separate type section.</span>
    918. 

  918. <span class="Keyword">var</span> <span class="Identifier">building</span><span class="Punctuation">:</span> <span class="Keyword">tuple</span><span class="Punctuation">[</span><span class="Identifier">street</span><span class="Punctuation">:</span> <span class="Identifier">string</span><span class="Punctuation">,</span> <span class="Identifier">number</span><span class="Punctuation">:</span> <span class="Identifier">int</span><span class="Punctuation">]</span>
    919. 

  919. <span class="Identifier">building</span> <span class="Operator">=</span> <span class="Punctuation">(</span><span class="StringLit">&quot;Rue del Percebe&quot;</span><span class="Punctuation">,</span> <span class="DecNumber">13</span><span class="Punctuation">)</span>
    920. 

  920. <span class="Identifier">echo</span> <span class="Identifier">building</span><span class="Operator">.</span><span class="Identifier">street</span>
    921. 

  921. 

  922. <span class="Comment"># The following line does not compile, they are different tuples!</span>
    923. 

  923. <span class="Comment">#person = building</span>
    924. 

  924. <span class="Comment"># --&gt; Error: type mismatch: got (tuple[street: string, number: int])</span>
    925. 

  925. <span class="Comment">#     but expected 'Person'</span></pre></p>
    926. 

  926. <p>Even though you don't need to declare a type for a tuple to use it, tuples created with different field names will be considered different objects despite having the same field types.</p>
    927. 

  927. <p>Tuples can be <em>unpacked</em> during variable assignment. This can be handy to assign directly the fields of the tuples to individually named variables. An example of this is the <a class="reference external" href="os.html#splitFile,string">splitFile</a> proc from the <a class="reference external" href="os.html">os module</a> which returns the directory, name, and extension of a path at the same time. For tuple unpacking to work you must use parentheses around the values you want to assign the unpacking to, otherwise, you will be assigning the same value to all the individual variables! For example:</p>
    928. 

  928. <p><pre class="listing"><span class="Keyword">import</span> <span class="Identifier">std</span><span class="Operator">/</span><span class="Identifier">os</span>
    929. 

  929. 

  930. <span class="Keyword">let</span>
    931. 

  931.   <span class="Identifier">path</span> <span class="Operator">=</span> <span class="StringLit">&quot;usr/local/nimc.html&quot;</span>
    932. 

  932.   <span class="Punctuation">(</span><span class="Identifier">dir</span><span class="Punctuation">,</span> <span class="Identifier">name</span><span class="Punctuation">,</span> <span class="Identifier">ext</span><span class="Punctuation">)</span> <span class="Operator">=</span> <span class="Identifier">splitFile</span><span class="Punctuation">(</span><span class="Identifier">path</span><span class="Punctuation">)</span>
    933. 

  933.   <span class="Identifier">baddir</span><span class="Punctuation">,</span> <span class="Identifier">badname</span><span class="Punctuation">,</span> <span class="Identifier">badext</span> <span class="Operator">=</span> <span class="Identifier">splitFile</span><span class="Punctuation">(</span><span class="Identifier">path</span><span class="Punctuation">)</span>
    934. 

  934. <span class="Identifier">echo</span> <span class="Identifier">dir</span>      <span class="Comment"># outputs &quot;usr/local&quot;</span>
    935. 

  935. <span class="Identifier">echo</span> <span class="Identifier">name</span>     <span class="Comment"># outputs &quot;nimc&quot;</span>
    936. 

  936. <span class="Identifier">echo</span> <span class="Identifier">ext</span>      <span class="Comment"># outputs &quot;.html&quot;</span>
    937. 

  937. <span class="Comment"># All the following output the same line:</span>
    938. 

  938. <span class="Comment"># &quot;(dir: usr/local, name: nimc, ext: .html)&quot;</span>
    939. 

  939. <span class="Identifier">echo</span> <span class="Identifier">baddir</span>
    940. 

  940. <span class="Identifier">echo</span> <span class="Identifier">badname</span>
    941. 

  941. <span class="Identifier">echo</span> <span class="Identifier">badext</span></pre></p>
    942. 

  942. <p>Tuple unpacking is also supported in for-loops:</p>
    943. 

  943. <p><pre class="listing"><span class="Keyword">let</span> <span class="Identifier">a</span> <span class="Operator">=</span> <span class="Punctuation">[</span><span class="Punctuation">(</span><span class="DecNumber">10</span><span class="Punctuation">,</span> <span class="CharLit">'a'</span><span class="Punctuation">)</span><span class="Punctuation">,</span> <span class="Punctuation">(</span><span class="DecNumber">20</span><span class="Punctuation">,</span> <span class="CharLit">'b'</span><span class="Punctuation">)</span><span class="Punctuation">,</span> <span class="Punctuation">(</span><span class="DecNumber">30</span><span class="Punctuation">,</span> <span class="CharLit">'c'</span><span class="Punctuation">)</span><span class="Punctuation">]</span>
    944. 

  944. 

  945. <span class="Keyword">for</span> <span class="Punctuation">(</span><span class="Identifier">x</span><span class="Punctuation">,</span> <span class="Identifier">c</span><span class="Punctuation">)</span> <span class="Keyword">in</span> <span class="Identifier">a</span><span class="Punctuation">:</span>
    946. 

  946.   <span class="Identifier">echo</span> <span class="Identifier">x</span>
    947. 

  947. <span class="Comment"># This will output: 10; 20; 30</span>
    948. 

  948. 

  949. <span class="Comment"># Accessing the index is also possible:</span>
    950. 

  950. <span class="Keyword">for</span> <span class="Identifier">i</span><span class="Punctuation">,</span> <span class="Punctuation">(</span><span class="Identifier">x</span><span class="Punctuation">,</span> <span class="Identifier">c</span><span class="Punctuation">)</span> <span class="Keyword">in</span> <span class="Identifier">a</span><span class="Punctuation">:</span>
    951. 

  951.   <span class="Identifier">echo</span> <span class="Identifier">i</span><span class="Punctuation">,</span> <span class="Identifier">c</span>
    952. 

  952. <span class="Comment"># This will output: 0a; 1b; 2c</span></pre></p>
    953. 

  953. <p>Fields of tuples are always public, they don't need to be explicitly marked to be exported, unlike for example fields in an object type.</p>
    954. 

  954. 

  955. <h2><a class="toc-backref" id="advanced-types-reference-and-pointer-types" href="#advanced-types-reference-and-pointer-types">Reference and pointer types</a></h2><p>References (similar to pointers in other programming languages) are a way to introduce many-to-one relationships. This means different references can point to and modify the same location in memory.</p>
    956. 

  956. <p>Nim distinguishes between <span id="traced_1">traced</span> and <span id="untraced_1">untraced</span> references. Untraced references are also called <em>pointers</em>. Traced references point to objects in a garbage-collected heap, untraced references point to manually allocated objects or objects elsewhere in memory. Thus, untraced references are <em>unsafe</em>. However, for certain low-level operations (e.g. accessing the hardware), untraced references are necessary.</p>
    957. 

  957. <p>Traced references are declared with the <strong>ref</strong> keyword; untraced references are declared with the <strong>ptr</strong> keyword.</p>
    958. 

  958. <p>The empty <tt class="docutils literal"><span class="pre"><span class="Punctuation">[</span><span class="Punctuation">]</span></span></tt> subscript notation can be used to <em>de-refer</em> a reference, meaning to retrieve the item the reference points to. The <tt class="docutils literal"><span class="pre"><span class="Operator">.</span></span></tt> (access a tuple/object field operator) and <tt class="docutils literal"><span class="pre"><span class="Punctuation">[</span><span class="Punctuation">]</span></span></tt> (array/string/sequence index operator) operators perform implicit dereferencing operations for reference types:</p>
    959. 

  959. <p><pre class="listing"><span class="Keyword">type</span>
    960. 

  960.   <span class="Identifier">Node</span> <span class="Operator">=</span> <span class="Keyword">ref</span> <span class="Keyword">object</span>
    961. 

  961.     <span class="Identifier">le</span><span class="Punctuation">,</span> <span class="Identifier">ri</span><span class="Punctuation">:</span> <span class="Identifier">Node</span>
    962. 

  962.     <span class="Identifier">data</span><span class="Punctuation">:</span> <span class="Identifier">int</span>
    963. 

  963. 

  964. <span class="Keyword">var</span> <span class="Identifier">n</span> <span class="Operator">=</span> <span class="Identifier">Node</span><span class="Punctuation">(</span><span class="Identifier">data</span><span class="Punctuation">:</span> <span class="DecNumber">9</span><span class="Punctuation">)</span>
    965. 

  965. <span class="Identifier">echo</span> <span class="Identifier">n</span><span class="Operator">.</span><span class="Identifier">data</span>
    966. 

  966. <span class="Comment"># no need to write n[].data; in fact n[].data is highly discouraged!</span></pre></p>
    967. 

  967. <p>To allocate a new traced object, the built-in procedure <tt class="docutils literal"><span class="pre"><span class="Identifier">new</span></span></tt> can be used:</p>
    968. 

  968. <p><pre class="listing"><span class="Keyword">var</span> <span class="Identifier">n</span><span class="Punctuation">:</span> <span class="Identifier">Node</span>
    969. 

  969. <span class="Identifier">new</span><span class="Punctuation">(</span><span class="Identifier">n</span><span class="Punctuation">)</span></pre></p>
    970. 

  970. <p>To deal with untraced memory, the procedures <tt class="docutils literal"><span class="pre"><span class="Identifier">alloc</span></span></tt>, <tt class="docutils literal"><span class="pre"><span class="Identifier">dealloc</span></span></tt> and <tt class="docutils literal"><span class="pre"><span class="Identifier">realloc</span></span></tt> can be used. The <a class="reference external" href="system.html">system</a> module's documentation contains further details.</p>
    971. 

  971. <p>If a reference points to <em>nothing</em>, it has the value <tt class="docutils literal"><span class="pre"><span class="Keyword">nil</span></span></tt>.</p>
    972. 

  972. 

  973. <h2><a class="toc-backref" id="advanced-types-procedural-type" href="#advanced-types-procedural-type">Procedural type</a></h2><p>A procedural type is a (somewhat abstract) pointer to a procedure. <tt class="docutils literal"><span class="pre"><span class="Keyword">nil</span></span></tt> is an allowed value for a variable of a procedural type. Nim uses procedural types to achieve <span id="functional_1">functional</span> programming techniques.</p>
    974. 

  974. <p>Example:</p>
    975. 

  975. <p><pre class="listing"><span class="Keyword">proc</span> <span class="Identifier">greet</span><span class="Punctuation">(</span><span class="Identifier">name</span><span class="Punctuation">:</span> <span class="Identifier">string</span><span class="Punctuation">)</span><span class="Punctuation">:</span> <span class="Identifier">string</span> <span class="Operator">=</span>
    976. 

  976.   <span class="StringLit">&quot;Hello, &quot;</span> <span class="Operator">&amp;</span> <span class="Identifier">name</span> <span class="Operator">&amp;</span> <span class="StringLit">&quot;!&quot;</span>
    977. 

  977. 

  978. <span class="Keyword">proc</span> <span class="Identifier">bye</span><span class="Punctuation">(</span><span class="Identifier">name</span><span class="Punctuation">:</span> <span class="Identifier">string</span><span class="Punctuation">)</span><span class="Punctuation">:</span> <span class="Identifier">string</span> <span class="Operator">=</span>
    979. 

  979.   <span class="StringLit">&quot;Goodbye, &quot;</span> <span class="Operator">&amp;</span> <span class="Identifier">name</span> <span class="Operator">&amp;</span> <span class="StringLit">&quot;.&quot;</span>
    980. 

  980. 

  981. <span class="Keyword">proc</span> <span class="Identifier">communicate</span><span class="Punctuation">(</span><span class="Identifier">greeting</span><span class="Punctuation">:</span> <span class="Keyword">proc</span> <span class="Punctuation">(</span><span class="Identifier">x</span><span class="Punctuation">:</span> <span class="Identifier">string</span><span class="Punctuation">)</span><span class="Punctuation">:</span> <span class="Identifier">string</span><span class="Punctuation">,</span> <span class="Identifier">name</span><span class="Punctuation">:</span> <span class="Identifier">string</span><span class="Punctuation">)</span> <span class="Operator">=</span>
    982. 

  982.   <span class="Identifier">echo</span> <span class="Identifier">greeting</span><span class="Punctuation">(</span><span class="Identifier">name</span><span class="Punctuation">)</span>
    983. 

  983. 

  984. <span class="Identifier">communicate</span><span class="Punctuation">(</span><span class="Identifier">greet</span><span class="Punctuation">,</span> <span class="StringLit">&quot;John&quot;</span><span class="Punctuation">)</span>
    985. 

  985. <span class="Identifier">communicate</span><span class="Punctuation">(</span><span class="Identifier">bye</span><span class="Punctuation">,</span> <span class="StringLit">&quot;Mary&quot;</span><span class="Punctuation">)</span></pre></p>
    986. 

  986. <p>A subtle issue with procedural types is that the calling convention of the procedure influences the type compatibility: procedural types are only compatible if they have the same calling convention. The different calling conventions are listed in the <a class="reference external" href="manual.html#types-procedural-type">manual</a>.</p>
    987. 

  987. 

  988. <h2><a class="toc-backref" id="advanced-types-distinct-type" href="#advanced-types-distinct-type">Distinct type</a></h2><p>A Distinct type allows for the creation of a new type that &quot;does not imply a subtype relationship between it and its base type&quot;. You must <strong>explicitly</strong> define all behavior for the distinct type. To help with this, both the distinct type and its base type can cast from one type to the other. Examples are provided in the <a class="reference external" href="manual.html#types-distinct-type">manual</a>.</p>
    989. 

  989. 

  990. <h1><a class="toc-backref" id="modules" href="#modules">Modules</a></h1><p>Nim supports splitting a program into pieces with a <em>module</em> concept. Each module is in its own file. Modules enable <span id="information-hiding_1">information hiding</span> and <span id="separate-compilation_1">separate compilation</span>. A module may gain access to the symbols of another module by using the <span id="import_1">import</span> statement. Only top-level symbols that are marked with an asterisk (<tt class="docutils literal"><span class="pre"><span class="Operator">*</span></span></tt>) are exported:</p>
    991. 

  991. <p><pre class="listing"><span class="Comment"># Module A</span>
    992. 

  992. <span class="Keyword">var</span>
    993. 

  993.   <span class="Identifier">x</span><span class="Operator">*</span><span class="Punctuation">,</span> <span class="Identifier">y</span><span class="Punctuation">:</span> <span class="Identifier">int</span>
    994. 

  994. 

  995. <span class="Keyword">proc</span> <span class="Punctuation">`</span><span class="Operator">*</span><span class="Punctuation">`</span> <span class="Operator">*</span><span class="Punctuation">(</span><span class="Identifier">a</span><span class="Punctuation">,</span> <span class="Identifier">b</span><span class="Punctuation">:</span> <span class="Identifier">seq</span><span class="Punctuation">[</span><span class="Identifier">int</span><span class="Punctuation">]</span><span class="Punctuation">)</span><span class="Punctuation">:</span> <span class="Identifier">seq</span><span class="Punctuation">[</span><span class="Identifier">int</span><span class="Punctuation">]</span> <span class="Operator">=</span>
    996. 

  996.   <span class="Comment"># allocate a new sequence:</span>
    997. 

  997.   <span class="Identifier">newSeq</span><span class="Punctuation">(</span><span class="Identifier">result</span><span class="Punctuation">,</span> <span class="Identifier">len</span><span class="Punctuation">(</span><span class="Identifier">a</span><span class="Punctuation">)</span><span class="Punctuation">)</span>
    998. 

  998.   <span class="Comment"># multiply two int sequences:</span>
    999. 

  999.   <span class="Keyword">for</span> <span class="Identifier">i</span> <span class="Keyword">in</span> <span class="DecNumber">0</span> <span class="Operator">..&lt;</span> <span class="Identifier">len</span><span class="Punctuation">(</span><span class="Identifier">a</span><span class="Punctuation">)</span><span class="Punctuation">:</span> <span class="Identifier">result</span><span class="Punctuation">[</span><span class="Identifier">i</span><span class="Punctuation">]</span> <span class="Operator">=</span> <span class="Identifier">a</span><span class="Punctuation">[</span><span class="Identifier">i</span><span class="Punctuation">]</span> <span class="Operator">*</span> <span class="Identifier">b</span><span class="Punctuation">[</span><span class="Identifier">i</span><span class="Punctuation">]</span>
    1000. 

  1000. 

  1001. <span class="Keyword">when</span> <span class="Identifier">isMainModule</span><span class="Punctuation">:</span>
    1002. 

  1002.   <span class="Comment"># test the new `*` operator for sequences:</span>
    1003. 

  1003.   <span class="Identifier">assert</span><span class="Punctuation">(</span><span class="Operator">@</span><span class="Punctuation">[</span><span class="DecNumber">1</span><span class="Punctuation">,</span> <span class="DecNumber">2</span><span class="Punctuation">,</span> <span class="DecNumber">3</span><span class="Punctuation">]</span> <span class="Operator">*</span> <span class="Operator">@</span><span class="Punctuation">[</span><span class="DecNumber">1</span><span class="Punctuation">,</span> <span class="DecNumber">2</span><span class="Punctuation">,</span> <span class="DecNumber">3</span><span class="Punctuation">]</span> <span class="Operator">==</span> <span class="Operator">@</span><span class="Punctuation">[</span><span class="DecNumber">1</span><span class="Punctuation">,</span> <span class="DecNumber">4</span><span class="Punctuation">,</span> <span class="DecNumber">9</span><span class="Punctuation">]</span><span class="Punctuation">)</span></pre></p>
    1004. 

  1004. <p>The above module exports <tt class="docutils literal"><span class="pre"><span class="Identifier">x</span></span></tt> and <tt class="docutils literal"><span class="pre"><span class="Operator">*</span></span></tt>, but not <tt class="docutils literal"><span class="pre"><span class="Identifier">y</span></span></tt>.</p>
    1005. 

  1005. <p>A module's top-level statements are executed at the start of the program. This can be used to initialize complex data structures for example.</p>
    1006. 

  1006. <p>Each module has a special magic constant <tt class="docutils literal"><span class="pre"><span class="Identifier">isMainModule</span></span></tt> that is true if the module is compiled as the main file. This is very useful to embed tests within the module as shown by the above example.</p>
    1007. 

  1007. <p>A symbol of a module <em>can</em> be <em>qualified</em> with the <tt class="docutils literal"><span class="pre"><span class="Identifier">module</span><span class="Operator">.</span><span class="Identifier">symbol</span></span></tt> syntax. And if a symbol is ambiguous, it <em>must</em> be qualified. A symbol is ambiguous if it is defined in two (or more) different modules and both modules are imported by a third one:</p>
    1008. 

  1008. <p><pre class="listing"><span class="Comment"># Module A</span>
    1009. 

  1009. <span class="Keyword">var</span> <span class="Identifier">x</span><span class="Operator">*:</span> <span class="Identifier">string</span></pre></p>
    1010. 

  1010. <p><pre class="listing"><span class="Comment"># Module B</span>
    1011. 

  1011. <span class="Keyword">var</span> <span class="Identifier">x</span><span class="Operator">*:</span> <span class="Identifier">int</span></pre></p>
    1012. 

  1012. <p><pre class="listing"><span class="Comment"># Module C</span>
    1013. 

  1013. <span class="Keyword">import</span> <span class="Identifier">A</span><span class="Punctuation">,</span> <span class="Identifier">B</span>
    1014. 

  1014. <span class="Identifier">write</span><span class="Punctuation">(</span><span class="Identifier">stdout</span><span class="Punctuation">,</span> <span class="Identifier">x</span><span class="Punctuation">)</span> <span class="Comment"># error: x is ambiguous</span>
    1015. 

  1015. <span class="Identifier">write</span><span class="Punctuation">(</span><span class="Identifier">stdout</span><span class="Punctuation">,</span> <span class="Identifier">A</span><span class="Operator">.</span><span class="Identifier">x</span><span class="Punctuation">)</span> <span class="Comment"># okay: qualifier used</span>
    1016. 

  1016. 

  1017. <span class="Keyword">var</span> <span class="Identifier">x</span> <span class="Operator">=</span> <span class="DecNumber">4</span>
    1018. 

  1018. <span class="Identifier">write</span><span class="Punctuation">(</span><span class="Identifier">stdout</span><span class="Punctuation">,</span> <span class="Identifier">x</span><span class="Punctuation">)</span> <span class="Comment"># not ambiguous: uses the module C's x</span></pre></p>
    1019. 

  1019. <p>But this rule does not apply to procedures or iterators. Here the overloading rules apply:</p>
    1020. 

  1020. <p><pre class="listing"><span class="Comment"># Module A</span>
    1021. 

  1021. <span class="Keyword">proc</span> <span class="Identifier">x</span><span class="Operator">*</span><span class="Punctuation">(</span><span class="Identifier">a</span><span class="Punctuation">:</span> <span class="Identifier">int</span><span class="Punctuation">)</span><span class="Punctuation">:</span> <span class="Identifier">string</span> <span class="Operator">=</span> <span class="Operator">$</span><span class="Identifier">a</span></pre></p>
    1022. 

  1022. <p><pre class="listing"><span class="Comment"># Module B</span>
    1023. 

  1023. <span class="Keyword">proc</span> <span class="Identifier">x</span><span class="Operator">*</span><span class="Punctuation">(</span><span class="Identifier">a</span><span class="Punctuation">:</span> <span class="Identifier">string</span><span class="Punctuation">)</span><span class="Punctuation">:</span> <span class="Identifier">string</span> <span class="Operator">=</span> <span class="Operator">$</span><span class="Identifier">a</span></pre></p>
    1024. 

  1024. <p><pre class="listing"><span class="Comment"># Module C</span>
    1025. 

  1025. <span class="Keyword">import</span> <span class="Identifier">A</span><span class="Punctuation">,</span> <span class="Identifier">B</span>
    1026. 

  1026. <span class="Identifier">write</span><span class="Punctuation">(</span><span class="Identifier">stdout</span><span class="Punctuation">,</span> <span class="Identifier">x</span><span class="Punctuation">(</span><span class="DecNumber">3</span><span class="Punctuation">)</span><span class="Punctuation">)</span>   <span class="Comment"># no error: A.x is called</span>
    1027. 

  1027. <span class="Identifier">write</span><span class="Punctuation">(</span><span class="Identifier">stdout</span><span class="Punctuation">,</span> <span class="Identifier">x</span><span class="Punctuation">(</span><span class="StringLit">&quot;&quot;</span><span class="Punctuation">)</span><span class="Punctuation">)</span>  <span class="Comment"># no error: B.x is called</span>
    1028. 

  1028. 

  1029. <span class="Keyword">proc</span> <span class="Identifier">x</span><span class="Operator">*</span><span class="Punctuation">(</span><span class="Identifier">a</span><span class="Punctuation">:</span> <span class="Identifier">int</span><span class="Punctuation">)</span><span class="Punctuation">:</span> <span class="Identifier">string</span> <span class="Operator">=</span> <span class="Keyword">discard</span>
    1030. 

  1030. <span class="Identifier">write</span><span class="Punctuation">(</span><span class="Identifier">stdout</span><span class="Punctuation">,</span> <span class="Identifier">x</span><span class="Punctuation">(</span><span class="DecNumber">3</span><span class="Punctuation">)</span><span class="Punctuation">)</span>   <span class="Comment"># ambiguous: which `x` is to call?</span></pre></p>
    1031. 

  1031. 

  1032. <h2><a class="toc-backref" id="modules-excluding-symbols" href="#modules-excluding-symbols">Excluding symbols</a></h2><p>The normal <tt class="docutils literal"><span class="pre"><span class="Keyword">import</span></span></tt> statement will bring in all exported symbols. These can be limited by naming symbols that should be excluded using the <tt class="docutils literal"><span class="pre"><span class="Keyword">except</span></span></tt> qualifier.</p>
    1033. 

  1033. <p><pre class="listing"><span class="Keyword">import</span> <span class="Identifier">mymodule</span> <span class="Keyword">except</span> <span class="Identifier">y</span></pre></p>
    1034. 

  1034. 

  1035. <h2><a class="toc-backref" id="modules-from-statement" href="#modules-from-statement">From statement</a></h2><p>We have already seen the simple <tt class="docutils literal"><span class="pre"><span class="Keyword">import</span></span></tt> statement that just imports all exported symbols. An alternative that only imports listed symbols is the <tt class="docutils literal"><span class="pre"><span class="Keyword">from</span> <span class="Keyword">import</span></span></tt> statement:</p>
    1036. 

  1036. <p><pre class="listing"><span class="Keyword">from</span> <span class="Identifier">mymodule</span> <span class="Keyword">import</span> <span class="Identifier">x</span><span class="Punctuation">,</span> <span class="Identifier">y</span><span class="Punctuation">,</span> <span class="Identifier">z</span></pre></p>
    1037. 

  1037. <p>The <tt class="docutils literal"><span class="pre"><span class="Keyword">from</span></span></tt> statement can also force namespace qualification on symbols, thereby making symbols available, but needing to be qualified in order to be used.</p>
    1038. 

  1038. <p><pre class="listing"><span class="Keyword">from</span> <span class="Identifier">mymodule</span> <span class="Keyword">import</span> <span class="Identifier">x</span><span class="Punctuation">,</span> <span class="Identifier">y</span><span class="Punctuation">,</span> <span class="Identifier">z</span>
    1039. 

  1039. 

  1040. <span class="Identifier">x</span><span class="Punctuation">(</span><span class="Punctuation">)</span>           <span class="Comment"># use x without any qualification</span></pre></p>
    1041. 

  1041. <p><pre class="listing"><span class="Keyword">from</span> <span class="Identifier">mymodule</span> <span class="Keyword">import</span> <span class="Keyword">nil</span>
    1042. 

  1042. 

  1043. <span class="Identifier">mymodule</span><span class="Operator">.</span><span class="Identifier">x</span><span class="Punctuation">(</span><span class="Punctuation">)</span>  <span class="Comment"># must qualify x with the module name as prefix</span>
    1044. 

  1044. 

  1045. <span class="Identifier">x</span><span class="Punctuation">(</span><span class="Punctuation">)</span>           <span class="Comment"># using x here without qualification is a compile error</span></pre></p>
    1046. 

  1046. <p>Since module names are generally long to be descriptive, you can also define a shorter alias to use when qualifying symbols.</p>
    1047. 

  1047. <p><pre class="listing"><span class="Keyword">from</span> <span class="Identifier">mymodule</span> <span class="Keyword">as</span> <span class="Identifier">m</span> <span class="Keyword">import</span> <span class="Keyword">nil</span>
    1048. 

  1048. 

  1049. <span class="Identifier">m</span><span class="Operator">.</span><span class="Identifier">x</span><span class="Punctuation">(</span><span class="Punctuation">)</span>         <span class="Comment"># m is aliasing mymodule</span></pre></p>
    1050. 

  1050. 

  1051. <h2><a class="toc-backref" id="modules-include-statement" href="#modules-include-statement">Include statement</a></h2><p>The <tt class="docutils literal"><span class="pre"><span class="Keyword">include</span></span></tt> statement does something fundamentally different than importing a module: it merely includes the contents of a file. The <tt class="docutils literal"><span class="pre"><span class="Keyword">include</span></span></tt> statement is useful to split up a large module into several files:</p>
    1052. 

  1052. <p><pre class="listing"><span class="Keyword">include</span> <span class="Identifier">fileA</span><span class="Punctuation">,</span> <span class="Identifier">fileB</span><span class="Punctuation">,</span> <span class="Identifier">fileC</span></pre></p>
    1053. 

  1053. 

  1054. <h1><a class="toc-backref" id="part-2" href="#part-2">Part 2</a></h1><p>So, now that we are done with the basics, let's see what Nim offers apart from a nice syntax for procedural programming: <a class="reference external" href="tut2.html">Part II</a></p>
    1055. 

  1055. </p>
    1056. 

  1056.     
    1057. 

  1057.   </div>
    1058. 

  1058. </div>
    1059. 

  1059. 

  1060.       <div class="twelve-columns footer">
    1061. 

  1061.         <span class="nim-sprite"></span>
    1062. 

  1062.         <br>
    1063. 

  1063.         <small style="color: var(--hint);">Made with Nim. Generated: 2025-01-09 12:00:02 UTC</small>
    1064. 

  1064.       </div>
    1065. 

  1065.     </div>
    1066. 

  1066.   </div>
    1067. 

  1067.       <script defer data-domain="nim-lang.org" src="https://plausible.io/js/plausible.js"></script>
    1068. 

  1068.     
    1069. 

  1069. </body>
    1070. 

  1070. </html>
    1071. 

  1071.