levovix
/
Nim
의 미러 https://github.com/nim-lang/Nim


			
				
					
						
						
							123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516
							<?xml version="1.0" encoding="utf-8" ?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<!--  This file is generated by Nim. -->
<html xmlns="https://www.w3.org/1999/xhtml" xml:lang="en" lang="en" data-theme="auto">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>std/strformat</title>

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

<!-- Favicon -->
<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=="/>
<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=">

<!-- CSS -->
<link rel="stylesheet" type="text/css" href="nimdoc.out.css?v=2.3.1">

<!-- JS -->
<script type="text/javascript" src="dochack.js?v=2.3.1"></script>
</head>
<body>
  <div class="document" id="documentId">
    <div class="container">
      <h1 class="title">std/strformat</h1>
      <div class="row">
  <div class="three columns">
    <div class="theme-select-wrapper">
      <label for="theme-select">Theme:&nbsp;</label>
      <select id="theme-select" onchange="setTheme(this.value)">
        <option value="auto">🌗 Match OS</option>
        <option value="dark">🌑 Dark</option>
        <option value="light">🌕 Light</option>
      </select>
    </div>
    <div id="global-links">
      <ul class="simple-boot">
        <li><a href="manual.html">Manual</a></li>
        <li><a href="lib.html">Standard library</a></li>
        <li> <a id="indexLink" href="theindex.html">Index</a></li>
        <li><a href="compiler/theindex.html">Compiler docs</a></li>
        <li><a href="https://nim-lang.github.io/fusion/theindex.html">Fusion docs</a></li>
        <li><a href="https://nim-lang.github.io/Nim/">devel</a>, <a href="https://nim-lang.org/documentation.html">stable</a></li>
      </ul>
    </div>
    <div id="searchInputDiv">
      Search: <input type="search" id="searchInput"
        oninput="search()" />
    </div>
    
    <ul class="simple simple-toc" id="toc-list">
  <li><a class="reference" id="nimfmt-vsdot-nimamp_toc" href="#nimfmt-vsdot-nimamp"><tt class="docutils literal"><span class="pre"><span class="Identifier">fmt</span></span></tt> vs. <tt class="docutils literal"><span class="pre"><span class="Operator">&amp;</span></span></tt></a></li>
<li><a class="reference" id="formatting-strings_toc" href="#formatting-strings">Formatting strings</a></li>
<li><a class="reference" id="formatting-floats_toc" href="#formatting-floats">Formatting floats</a></li>
<li><a class="reference" id="expressions_toc" href="#expressions">Expressions</a></li>
<li><a class="reference" id="debugging-strings_toc" href="#debugging-strings">Debugging strings</a></li>
<li><a class="reference" id="implementation-details_toc" href="#implementation-details">Implementation details</a></li>
<li><a class="reference" id="standard-format-specifiers-for-strings-integers-and-floats_toc" href="#standard-format-specifiers-for-strings-integers-and-floats">Standard format specifiers for strings, integers and floats</a></li>
<li><a class="reference" id="limitations_toc" href="#limitations">Limitations</a></li>
<li><a class="reference" id="future-directions_toc" href="#future-directions">Future directions</a></li>
<li>
  <a class="reference reference-toplevel" href="#6" id="56">Imports</a>
</li>
<li>
  <details open>
    <summary><a class="reference reference-toplevel" href="#7" id="57">Types</a></summary>
    <ul class="simple simple-toc-section">
      <li><a class="reference" href="#StandardFormatSpecifier" title="StandardFormatSpecifier = object
  fill*, align*: char        ## Desired fill and alignment.
  sign*: char                ## Desired sign.
  alternateForm*: bool       ## Whether to prefix binary, octal and hex numbers
                             ## with `0b`, `0o`, `0x`.
  padWithZero*: bool         ## Whether to pad with zeros rather than spaces.
  minimumWidth*, precision*: int ## Desired minimum width and precision.
  typ*: char                 ## Type like 'f', 'g' or 'd'.
  endPosition*: int          ## End position in the format specifier after
                             ## `parseStandardFormatSpecifier` returned.">StandardFormatSpecifier</a></li>

    </ul>
  </details>
</li>
<li>
  <details open>
    <summary><a class="reference reference-toplevel" href="#12" id="62">Procs</a></summary>
    <ul class="simple simple-toc-section">
      <ul class="simple nested-toc-section">alignString
  <li><a class="reference" href="#alignString%2Cstring%2Cint%2Cchar%2Cchar" title="alignString(s: string; minimumWidth: int; align = '\x00'; fill = ' '): string">alignString(s: string; minimumWidth: int; align = '\x00'; fill = ' '): string</a></li>

</ul>
<ul class="simple nested-toc-section">formatValue
  <li><a class="reference" href="#formatValue%2Cstring%2CSomeFloat%2Cstaticstring" title="formatValue(result: var string; value: SomeFloat; specifier: static string)">formatValue(result: var string; value: SomeFloat; specifier: static string)</a></li>
<li><a class="reference" href="#formatValue%2Cstring%2CSomeFloat%2Cstring" title="formatValue(result: var string; value: SomeFloat; specifier: string)">formatValue(result: var string; value: SomeFloat; specifier: string)</a></li>
<li><a class="reference" href="#formatValue%2Cstring%2Cstring%2Cstaticstring" title="formatValue(result: var string; value: string; specifier: static string)">formatValue(result: var string; value: string; specifier: static string)</a></li>
<li><a class="reference" href="#formatValue%2Cstring%2Cstring%2Cstring" title="formatValue(result: var string; value: string; specifier: string)">formatValue(result: var string; value: string; specifier: string)</a></li>
<li><a class="reference" href="#formatValue%2Cstring%2CT%2Cstaticstring" title="formatValue[T: SomeInteger](result: var string; value: T;
                            specifier: static string)">formatValue[T: SomeInteger](result: var string; value: T;
                            specifier: static string)</a></li>
<li><a class="reference" href="#formatValue%2Cstring%2CT%2Cstring" title="formatValue[T: SomeInteger](result: var string; value: T; specifier: string)">formatValue[T: SomeInteger](result: var string; value: T; specifier: string)</a></li>

</ul>
<ul class="simple nested-toc-section">parseStandardFormatSpecifier
  <li><a class="reference" href="#parseStandardFormatSpecifier%2Cstring%2Cint" title="parseStandardFormatSpecifier(s: string; start = 0; ignoreUnknownSuffix = false): StandardFormatSpecifier">parseStandardFormatSpecifier(s: string; start = 0; ignoreUnknownSuffix = false): StandardFormatSpecifier</a></li>

</ul>

    </ul>
  </details>
</li>
<li>
  <details open>
    <summary><a class="reference reference-toplevel" href="#18" id="68">Templates</a></summary>
    <ul class="simple simple-toc-section">
      <ul class="simple nested-toc-section">&
  <li><a class="reference" href="#%26.t" title="`&amp;`(pattern: string{lit}): string">`&amp;`(pattern: string{lit}): string</a></li>

</ul>
<ul class="simple nested-toc-section">fmt
  <li><a class="reference" href="#fmt.t%2Cstaticstring" title="fmt(pattern: static string): untyped">fmt(pattern: static string): untyped</a></li>
<li><a class="reference" href="#fmt.t%2Cstaticstring%2Cstaticchar%2Cstaticchar" title="fmt(pattern: static string; openChar: static char; closeChar: static char): string">fmt(pattern: static string; openChar: static char; closeChar: static char): string</a></li>

</ul>

    </ul>
  </details>
</li>

</ul>

  </div>
  <div class="nine columns" id="content">
    <a href="https://github.com/nim-lang/Nim/tree/devel/lib/pure/strformat.nim#L1" class="link-seesrc" target="_blank">Source</a>&nbsp;&nbsp;
<a href="https://github.com/nim-lang/Nim/edit/devel/lib/pure/strformat.nim#L1" class="link-seesrc" target="_blank" >Edit</a>&nbsp;&nbsp;

    <div id="tocRoot"></div>
    
    <p class="module-desc">String <span id="interpolation_1">interpolation</span> / <span id="format_1">format</span> inspired by Python's f-strings.
<h1><a class="toc-backref" id="nimfmt-vsdot-nimamp" href="#nimfmt-vsdot-nimamp"><tt class="docutils literal"><span class="pre"><span class="Identifier">fmt</span></span></tt> vs. <tt class="docutils literal"><span class="pre"><span class="Operator">&amp;</span></span></tt></a></h1><p>You can use either <tt class="docutils literal"><span class="pre"><span class="Identifier">fmt</span></span></tt> or the unary <tt class="docutils literal"><span class="pre"><span class="Operator">&amp;</span></span></tt> operator for formatting. The difference between them is subtle but important.</p>
<p>The <tt class="docutils literal"><span class="pre"><span class="RawData">fmt&quot;{expr}&quot;</span></span></tt> syntax is more aesthetically pleasing, but it hides a small gotcha. The string is a <a class="reference external" href="manual.html#lexical-analysis-generalized-raw-string-literals">generalized raw string literal</a>. This has some surprising effects: </p>

<p><strong class="examples_text">Example:</strong></p>
<pre class="listing"><span class="Keyword">import</span> <span class="Identifier">std</span><span class="Operator">/</span><span class="Identifier">strformat</span>
<span class="Keyword">let</span> <span class="Identifier">msg</span> <span class="Operator">=</span> <span class="StringLit">&quot;hello&quot;</span>
<span class="Identifier">assert</span> <span class="RawData">fmt&quot;{msg}\n&quot;</span> <span class="Operator">==</span> <span class="StringLit">&quot;hello</span><span class="EscapeSequence">\\</span><span class="StringLit">n&quot;</span></pre><p>Because the literal is a raw string literal, the <tt class="docutils literal"><span class="pre"><span class="Operator">\</span><span class="Identifier">n</span></span></tt> is not interpreted as an escape sequence.</p>
<p>There are multiple ways to get around this, including the use of the <tt class="docutils literal"><span class="pre"><span class="Operator">&amp;</span></span></tt> operator: </p>

<p><strong class="examples_text">Example:</strong></p>
<pre class="listing"><span class="Keyword">import</span> <span class="Identifier">std</span><span class="Operator">/</span><span class="Identifier">strformat</span>
<span class="Keyword">let</span> <span class="Identifier">msg</span> <span class="Operator">=</span> <span class="StringLit">&quot;hello&quot;</span>

<span class="Identifier">assert</span> <span class="Operator">&amp;</span><span class="StringLit">&quot;{msg}</span><span class="EscapeSequence">\n</span><span class="StringLit">&quot;</span> <span class="Operator">==</span> <span class="StringLit">&quot;hello</span><span class="EscapeSequence">\n</span><span class="StringLit">&quot;</span>

<span class="Identifier">assert</span> <span class="RawData">fmt&quot;{msg}{'\n'}&quot;</span> <span class="Operator">==</span> <span class="StringLit">&quot;hello</span><span class="EscapeSequence">\n</span><span class="StringLit">&quot;</span>
<span class="Identifier">assert</span> <span class="Identifier">fmt</span><span class="Punctuation">(</span><span class="StringLit">&quot;{msg}</span><span class="EscapeSequence">\n</span><span class="StringLit">&quot;</span><span class="Punctuation">)</span> <span class="Operator">==</span> <span class="StringLit">&quot;hello</span><span class="EscapeSequence">\n</span><span class="StringLit">&quot;</span>
<span class="Identifier">assert</span> <span class="StringLit">&quot;{msg}</span><span class="EscapeSequence">\n</span><span class="StringLit">&quot;</span><span class="Operator">.</span><span class="Identifier">fmt</span> <span class="Operator">==</span> <span class="StringLit">&quot;hello</span><span class="EscapeSequence">\n</span><span class="StringLit">&quot;</span></pre>The choice of style is up to you.
<h1><a class="toc-backref" id="formatting-strings" href="#formatting-strings">Formatting strings</a></h1>
<p><strong class="examples_text">Example:</strong></p>
<pre class="listing"><span class="Keyword">import</span> <span class="Identifier">std</span><span class="Operator">/</span><span class="Identifier">strformat</span>
<span class="Identifier">assert</span> <span class="Operator">&amp;</span><span class="LongStringLit">&quot;&quot;&quot;{&quot;abc&quot;:&gt;4}&quot;&quot;&quot;</span> <span class="Operator">==</span> <span class="StringLit">&quot; abc&quot;</span>
<span class="Identifier">assert</span> <span class="Operator">&amp;</span><span class="LongStringLit">&quot;&quot;&quot;{&quot;abc&quot;:&lt;4}&quot;&quot;&quot;</span> <span class="Operator">==</span> <span class="StringLit">&quot;abc &quot;</span></pre>
<h1><a class="toc-backref" id="formatting-floats" href="#formatting-floats">Formatting floats</a></h1>
<p><strong class="examples_text">Example:</strong></p>
<pre class="listing"><span class="Keyword">import</span> <span class="Identifier">std</span><span class="Operator">/</span><span class="Identifier">strformat</span>
<span class="Identifier">assert</span> <span class="RawData">fmt&quot;{-12345:08}&quot;</span> <span class="Operator">==</span> <span class="StringLit">&quot;-0012345&quot;</span>
<span class="Identifier">assert</span> <span class="RawData">fmt&quot;{-1:3}&quot;</span> <span class="Operator">==</span> <span class="StringLit">&quot; -1&quot;</span>
<span class="Identifier">assert</span> <span class="RawData">fmt&quot;{-1:03}&quot;</span> <span class="Operator">==</span> <span class="StringLit">&quot;-01&quot;</span>
<span class="Identifier">assert</span> <span class="RawData">fmt&quot;{16:#X}&quot;</span> <span class="Operator">==</span> <span class="StringLit">&quot;0x10&quot;</span>

<span class="Identifier">assert</span> <span class="RawData">fmt&quot;{123.456}&quot;</span> <span class="Operator">==</span> <span class="StringLit">&quot;123.456&quot;</span>
<span class="Identifier">assert</span> <span class="RawData">fmt&quot;{123.456:&gt;9.3f}&quot;</span> <span class="Operator">==</span> <span class="StringLit">&quot;  123.456&quot;</span>
<span class="Identifier">assert</span> <span class="RawData">fmt&quot;{123.456:9.3f}&quot;</span> <span class="Operator">==</span> <span class="StringLit">&quot;  123.456&quot;</span>
<span class="Identifier">assert</span> <span class="RawData">fmt&quot;{123.456:9.4f}&quot;</span> <span class="Operator">==</span> <span class="StringLit">&quot; 123.4560&quot;</span>
<span class="Identifier">assert</span> <span class="RawData">fmt&quot;{123.456:&gt;9.0f}&quot;</span> <span class="Operator">==</span> <span class="StringLit">&quot;     123.&quot;</span>
<span class="Identifier">assert</span> <span class="RawData">fmt&quot;{123.456:&lt;9.4f}&quot;</span> <span class="Operator">==</span> <span class="StringLit">&quot;123.4560 &quot;</span>

<span class="Identifier">assert</span> <span class="RawData">fmt&quot;{123.456:e}&quot;</span> <span class="Operator">==</span> <span class="StringLit">&quot;1.234560e+02&quot;</span>
<span class="Identifier">assert</span> <span class="RawData">fmt&quot;{123.456:&gt;13e}&quot;</span> <span class="Operator">==</span> <span class="StringLit">&quot; 1.234560e+02&quot;</span>
<span class="Identifier">assert</span> <span class="RawData">fmt&quot;{123.456:13e}&quot;</span> <span class="Operator">==</span> <span class="StringLit">&quot; 1.234560e+02&quot;</span></pre>
<h1><a class="toc-backref" id="expressions" href="#expressions">Expressions</a></h1>
<p><strong class="examples_text">Example:</strong></p>
<pre class="listing"><span class="Keyword">import</span> <span class="Identifier">std</span><span class="Operator">/</span><span class="Identifier">strformat</span>
<span class="Keyword">let</span> <span class="Identifier">x</span> <span class="Operator">=</span> <span class="FloatNumber">3.14</span>
<span class="Identifier">assert</span> <span class="RawData">fmt&quot;{(if x!=0: 1.0/x else: 0):.5}&quot;</span> <span class="Operator">==</span> <span class="StringLit">&quot;0.31847&quot;</span>
<span class="Identifier">assert</span> <span class="LongStringLit">fmt&quot;&quot;&quot;{(block:
    var res: string
    for i in 1..15:
      res.add (if i mod 15 == 0: &quot;FizzBuzz&quot;
        elif i mod 5 == 0: &quot;Buzz&quot;
        elif i mod 3 == 0: &quot;Fizz&quot;
        else: $i) &amp; &quot; &quot;
    res)}&quot;&quot;&quot;</span> <span class="Operator">==</span> <span class="StringLit">&quot;1 2 Fizz 4 Buzz Fizz 7 8 Fizz Buzz 11 Fizz 13 14 FizzBuzz &quot;</span></pre>
<h1><a class="toc-backref" id="debugging-strings" href="#debugging-strings">Debugging strings</a></h1><p><tt class="docutils literal"><span class="pre"><span class="RawData">fmt&quot;{expr=}&quot;</span></span></tt> expands to <tt class="docutils literal"><span class="pre"><span class="RawData">fmt&quot;expr={expr}&quot;</span></span></tt> namely the text of the expression, an equal sign and the results of evaluated expression. </p>

<p><strong class="examples_text">Example:</strong></p>
<pre class="listing"><span class="Keyword">import</span> <span class="Identifier">std</span><span class="Operator">/</span><span class="Identifier">strformat</span>
<span class="Identifier">assert</span> <span class="RawData">fmt&quot;{123.456=}&quot;</span> <span class="Operator">==</span> <span class="StringLit">&quot;123.456=123.456&quot;</span>
<span class="Identifier">assert</span> <span class="RawData">fmt&quot;{123.456=:&gt;9.3f}&quot;</span> <span class="Operator">==</span> <span class="StringLit">&quot;123.456=  123.456&quot;</span>

<span class="Keyword">let</span> <span class="Identifier">x</span> <span class="Operator">=</span> <span class="StringLit">&quot;hello&quot;</span>
<span class="Identifier">assert</span> <span class="RawData">fmt&quot;{x=}&quot;</span> <span class="Operator">==</span> <span class="StringLit">&quot;x=hello&quot;</span>
<span class="Identifier">assert</span> <span class="RawData">fmt&quot;{x =}&quot;</span> <span class="Operator">==</span> <span class="StringLit">&quot;x =hello&quot;</span>

<span class="Keyword">let</span> <span class="Identifier">y</span> <span class="Operator">=</span> <span class="FloatNumber">3.1415926</span>
<span class="Identifier">assert</span> <span class="RawData">fmt&quot;{y=:.2f}&quot;</span> <span class="Operator">==</span> <span class="RawData">fmt&quot;y={y:.2f}&quot;</span>
<span class="Identifier">assert</span> <span class="RawData">fmt&quot;{y=}&quot;</span> <span class="Operator">==</span> <span class="RawData">fmt&quot;y={y}&quot;</span>
<span class="Identifier">assert</span> <span class="RawData">fmt&quot;{y = : &lt;8}&quot;</span> <span class="Operator">==</span> <span class="RawData">fmt&quot;y = 3.14159 &quot;</span>

<span class="Keyword">proc</span> <span class="Identifier">hello</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="Identifier">b</span><span class="Punctuation">:</span> <span class="Identifier">float</span><span class="Punctuation">)</span><span class="Punctuation">:</span> <span class="Identifier">int</span> <span class="Operator">=</span> <span class="DecNumber">12</span>
<span class="Identifier">assert</span> <span class="RawData">fmt&quot;{hello(x, y) = }&quot;</span> <span class="Operator">==</span> <span class="StringLit">&quot;hello(x, y) = 12&quot;</span>
<span class="Identifier">assert</span> <span class="RawData">fmt&quot;{x.hello(y) = }&quot;</span> <span class="Operator">==</span> <span class="StringLit">&quot;x.hello(y) = 12&quot;</span>
<span class="Identifier">assert</span> <span class="RawData">fmt&quot;{hello x, y = }&quot;</span> <span class="Operator">==</span> <span class="StringLit">&quot;hello x, y = 12&quot;</span></pre>Note that it is space sensitive: 
<p><strong class="examples_text">Example:</strong></p>
<pre class="listing"><span class="Keyword">import</span> <span class="Identifier">std</span><span class="Operator">/</span><span class="Identifier">strformat</span>
<span class="Keyword">let</span> <span class="Identifier">x</span> <span class="Operator">=</span> <span class="StringLit">&quot;12&quot;</span>
<span class="Identifier">assert</span> <span class="RawData">fmt&quot;{x=}&quot;</span> <span class="Operator">==</span> <span class="StringLit">&quot;x=12&quot;</span>
<span class="Identifier">assert</span> <span class="RawData">fmt&quot;{x =:}&quot;</span> <span class="Operator">==</span> <span class="StringLit">&quot;x =12&quot;</span>
<span class="Identifier">assert</span> <span class="RawData">fmt&quot;{x =}&quot;</span> <span class="Operator">==</span> <span class="StringLit">&quot;x =12&quot;</span>
<span class="Identifier">assert</span> <span class="RawData">fmt&quot;{x= :}&quot;</span> <span class="Operator">==</span> <span class="StringLit">&quot;x= 12&quot;</span>
<span class="Identifier">assert</span> <span class="RawData">fmt&quot;{x= }&quot;</span> <span class="Operator">==</span> <span class="StringLit">&quot;x= 12&quot;</span>
<span class="Identifier">assert</span> <span class="RawData">fmt&quot;{x = :}&quot;</span> <span class="Operator">==</span> <span class="StringLit">&quot;x = 12&quot;</span>
<span class="Identifier">assert</span> <span class="RawData">fmt&quot;{x = }&quot;</span> <span class="Operator">==</span> <span class="StringLit">&quot;x = 12&quot;</span>
<span class="Identifier">assert</span> <span class="RawData">fmt&quot;{x   =  :}&quot;</span> <span class="Operator">==</span> <span class="StringLit">&quot;x   =  12&quot;</span>
<span class="Identifier">assert</span> <span class="RawData">fmt&quot;{x   =  }&quot;</span> <span class="Operator">==</span> <span class="StringLit">&quot;x   =  12&quot;</span></pre>
<h1><a class="toc-backref" id="implementation-details" href="#implementation-details">Implementation details</a></h1><p>An expression like <tt class="docutils literal"><span class="pre"><span class="Operator">&amp;</span><span class="StringLit">&quot;{key} is {value:arg} {{z}}&quot;</span></span></tt> is transformed into:</p>
<p><pre class="listing"><span class="Keyword">var</span> <span class="Identifier">temp</span> <span class="Operator">=</span> <span class="Identifier">newStringOfCap</span><span class="Punctuation">(</span><span class="Identifier">educatedCapGuess</span><span class="Punctuation">)</span>
<span class="Identifier">temp</span><span class="Operator">.</span><span class="Identifier">formatValue</span><span class="Punctuation">(</span><span class="Identifier">key</span><span class="Punctuation">,</span> <span class="StringLit">&quot;&quot;</span><span class="Punctuation">)</span>
<span class="Identifier">temp</span><span class="Operator">.</span><span class="Identifier">add</span><span class="Punctuation">(</span><span class="StringLit">&quot; is &quot;</span><span class="Punctuation">)</span>
<span class="Identifier">temp</span><span class="Operator">.</span><span class="Identifier">formatValue</span><span class="Punctuation">(</span><span class="Identifier">value</span><span class="Punctuation">,</span> <span class="Identifier">arg</span><span class="Punctuation">)</span>
<span class="Identifier">temp</span><span class="Operator">.</span><span class="Identifier">add</span><span class="Punctuation">(</span><span class="StringLit">&quot; {z}&quot;</span><span class="Punctuation">)</span>
<span class="Identifier">temp</span></pre></p>
<p>Parts of the string that are enclosed in the curly braces are interpreted as Nim code. To escape a <tt class="docutils literal"><span class="pre"><span class="Punctuation">{</span></span></tt> or <tt class="docutils literal"><span class="pre"><span class="Punctuation">}</span></span></tt>, double it.</p>
<p>Within a curly expression, however, <tt class="docutils literal"><span class="pre"><span class="Punctuation">{</span></span></tt>, <tt class="docutils literal"><span class="pre"><span class="Punctuation">}</span></span></tt>, must be escaped with a backslash.</p>
<p>To enable evaluating Nim expressions within curlies, colons inside parentheses do not need to be escaped. </p>

<p><strong class="examples_text">Example:</strong></p>
<pre class="listing"><span class="Keyword">import</span> <span class="Identifier">std</span><span class="Operator">/</span><span class="Identifier">strformat</span>
<span class="Keyword">let</span> <span class="Identifier">x</span> <span class="Operator">=</span> <span class="StringLit">&quot;hello&quot;</span>
<span class="Identifier">assert</span> <span class="LongStringLit">fmt&quot;&quot;&quot;{ &quot;\{(&quot; &amp; x &amp; &quot;)\}&quot; }&quot;&quot;&quot;</span> <span class="Operator">==</span> <span class="StringLit">&quot;{(hello)}&quot;</span>
<span class="Identifier">assert</span> <span class="LongStringLit">fmt&quot;&quot;&quot;{{({ x })}}&quot;&quot;&quot;</span> <span class="Operator">==</span> <span class="StringLit">&quot;{(hello)}&quot;</span>
<span class="Identifier">assert</span> <span class="LongStringLit">fmt&quot;&quot;&quot;{ $(\{x:1,&quot;world&quot;:2\}) }&quot;&quot;&quot;</span> <span class="Operator">==</span> <span class="LongStringLit">&quot;&quot;&quot;[(&quot;hello&quot;, 1), (&quot;world&quot;, 2)]&quot;&quot;&quot;</span></pre><p><tt class="docutils literal"><span class="pre"><span class="Operator">&amp;</span></span></tt> delegates most of the work to an open overloaded set of <tt class="docutils literal"><span class="pre"><span class="Identifier">formatValue</span></span></tt> procs. The required signature for a type <tt class="docutils literal"><span class="pre"><span class="Identifier">T</span></span></tt> that supports formatting is usually <tt class="docutils literal"><span class="pre"><span class="Keyword">proc</span> <span class="Identifier">formatValue</span><span class="Punctuation">(</span><span class="Identifier">result</span><span class="Punctuation">:</span> <span class="Keyword">var</span> <span class="Identifier">string</span><span class="Punctuation">;</span> <span class="Identifier">x</span><span class="Punctuation">:</span> <span class="Identifier">T</span><span class="Punctuation">;</span> <span class="Identifier">specifier</span><span class="Punctuation">:</span> <span class="Identifier">string</span><span class="Punctuation">)</span></span></tt>.</p>
<p>The subexpression after the colon (<tt class="docutils literal"><span class="pre"><span class="Identifier">arg</span></span></tt> in <tt class="docutils literal"><span class="pre"><span class="Operator">&amp;</span><span class="StringLit">&quot;{key} is {value:arg} {{z}}&quot;</span></span></tt>) is optional. It will be passed as the last argument to <tt class="docutils literal"><span class="pre"><span class="Identifier">formatValue</span></span></tt>. When the colon with the subexpression it is left out, an empty string will be taken instead.</p>
<p>For strings and numeric types the optional argument is a so-called &quot;standard format specifier&quot;.</p>

<h1><a class="toc-backref" id="standard-format-specifiers-for-strings-integers-and-floats" href="#standard-format-specifiers-for-strings-integers-and-floats">Standard format specifiers for strings, integers and floats</a></h1><p>The general form of a standard format specifier is:</p>
<pre>[[fill]align][sign][#][0][minimumwidth][.precision][type]</pre>
<p>The square brackets <tt class="docutils literal"><span class="pre"><span class="Punctuation">[</span><span class="Punctuation">]</span></span></tt> indicate an optional element.</p>
<p>The optional <tt class="docutils literal"><span class="pre"><span class="Identifier">align</span></span></tt> flag can be one of the following:</p>
<dl class="docutils"><dt><tt class="docutils literal"><span class="pre"><span class="Operator">&lt;</span></span></tt></dt>
<dd>Forces the field to be left-aligned within the available space. (This is the default for strings.)</dd>
<dt><tt class="docutils literal"><span class="pre"><span class="Operator">&gt;</span></span></tt></dt>
<dd>Forces the field to be right-aligned within the available space. (This is the default for numbers.)</dd>
<dt><tt class="docutils literal"><span class="pre"><span class="Operator">^</span></span></tt></dt>
<dd>Forces the field to be centered within the available space.</dd>
</dl>
<p>Note that unless a minimum field width is defined, the field width will always be the same size as the data to fill it, so that the alignment option has no meaning in this case.</p>
<p>The optional <tt class="docutils literal"><span class="pre"><span class="Identifier">fill</span></span></tt> character defines the character to be used to pad the field to the minimum width. The fill character, if present, must be followed by an alignment flag.</p>
<p>The <tt class="docutils literal"><span class="pre"><span class="Identifier">sign</span></span></tt> option is only valid for numeric types, and can be one of the following:</p>
<table border="1" class="docutils"><tr><th>Sign</th><th>Meaning</th></tr>
<tr><td><tt class="docutils literal"><span class="pre"><span class="Operator">+</span></span></tt></td><td>Indicates that a sign should be used for both positive as well as negative numbers.</td></tr>
<tr><td><tt class="docutils literal"><span class="pre"><span class="Operator">-</span></span></tt></td><td>Indicates that a sign should be used only for negative numbers (this is the default behavior).</td></tr>
<tr><td>(space)</td><td>Indicates that a leading space should be used on positive numbers.</td></tr>
</table><p>If the <tt class="docutils literal"><span class="pre"><span class="Comment">#</span></span></tt> character is present, integers use the 'alternate form' for formatting. This means that binary, octal and hexadecimal output will be prefixed with <tt class="docutils literal"><span class="pre"><span class="BinNumber">0b</span></span></tt>, <tt class="docutils literal"><span class="pre"><span class="OctNumber">0o</span></span></tt> and <tt class="docutils literal"><span class="pre"><span class="HexNumber">0x</span></span></tt>, respectively.</p>
<p><tt class="docutils literal"><span class="pre"><span class="Identifier">width</span></span></tt> is a decimal integer defining the minimum field width. If not specified, then the field width will be determined by the content.</p>
<p>If the width field is preceded by a zero (<tt class="docutils literal"><span class="pre"><span class="DecNumber">0</span></span></tt>) character, this enables zero-padding.</p>
<p>The <tt class="docutils literal"><span class="pre"><span class="Identifier">precision</span></span></tt> is a decimal number indicating how many digits should be displayed after the decimal point in a floating point conversion. For non-numeric types the field indicates the maximum field size - in other words, how many characters will be used from the field content. The precision is ignored for integer conversions.</p>
<p>Finally, the <tt class="docutils literal"><span class="pre"><span class="Keyword">type</span></span></tt> determines how the data should be presented.</p>
<p>The available integer presentation types are:</p>
<table border="1" class="docutils"><tr><th>Type</th><th>Result</th></tr>
<tr><td><tt class="docutils literal"><span class="pre"><span class="Identifier">b</span></span></tt></td><td>Binary. Outputs the number in base 2.</td></tr>
<tr><td><tt class="docutils literal"><span class="pre"><span class="Identifier">d</span></span></tt></td><td>Decimal Integer. Outputs the number in base 10.</td></tr>
<tr><td><tt class="docutils literal"><span class="pre"><span class="Identifier">o</span></span></tt></td><td>Octal format. Outputs the number in base 8.</td></tr>
<tr><td><tt class="docutils literal"><span class="pre"><span class="Identifier">x</span></span></tt></td><td>Hex format. Outputs the number in base 16, using lower-case letters for the digits above 9.</td></tr>
<tr><td><tt class="docutils literal"><span class="pre"><span class="Identifier">X</span></span></tt></td><td>Hex format. Outputs the number in base 16, using uppercase letters for the digits above 9.</td></tr>
<tr><td>(None)</td><td>The same as <tt class="docutils literal"><span class="pre"><span class="Identifier">d</span></span></tt>.</td></tr>
</table><p>The available floating point presentation types are:</p>
<table border="1" class="docutils"><tr><th>Type</th><th>Result</th></tr>
<tr><td><tt class="docutils literal"><span class="pre"><span class="Identifier">e</span></span></tt></td><td>Exponent notation. Prints the number in scientific notation using the letter <tt class="docutils literal"><span class="pre"><span class="Identifier">e</span></span></tt> to indicate the exponent.</td></tr>
<tr><td><tt class="docutils literal"><span class="pre"><span class="Identifier">E</span></span></tt></td><td>Exponent notation. Same as <tt class="docutils literal"><span class="pre"><span class="Identifier">e</span></span></tt> except it converts the number to uppercase.</td></tr>
<tr><td><tt class="docutils literal"><span class="pre"><span class="Identifier">f</span></span></tt></td><td>Fixed point. Displays the number as a fixed-point number.</td></tr>
<tr><td><tt class="docutils literal"><span class="pre"><span class="Identifier">F</span></span></tt></td><td>Fixed point. Same as <tt class="docutils literal"><span class="pre"><span class="Identifier">f</span></span></tt> except it converts the number to uppercase.</td></tr>
<tr><td><tt class="docutils literal"><span class="pre"><span class="Identifier">g</span></span></tt></td><td>General format. This prints the number as a fixed-point number, unless the number is too large, in which case it switches to <tt class="docutils literal"><span class="pre"><span class="Identifier">e</span></span></tt> exponent notation.</td></tr>
<tr><td><tt class="docutils literal"><span class="pre"><span class="Identifier">G</span></span></tt></td><td>General format. Same as <tt class="docutils literal"><span class="pre"><span class="Identifier">g</span></span></tt> except it switches to <tt class="docutils literal"><span class="pre"><span class="Identifier">E</span></span></tt> if the number gets to large.</td></tr>
<tr><td><tt class="docutils literal"><span class="pre"><span class="Identifier">i</span></span></tt></td><td>Complex General format. This is only supported for complex numbers, which it prints using the mathematical (RE+IMj) format. The real and imaginary parts are printed using the general format <tt class="docutils literal"><span class="pre"><span class="Identifier">g</span></span></tt> by default, but it is possible to combine this format with one of the other formats (e.g <tt class="docutils literal"><span class="pre"><span class="Identifier">jf</span></span></tt>).</td></tr>
<tr><td>(None)</td><td>Similar to <tt class="docutils literal"><span class="pre"><span class="Identifier">g</span></span></tt>, except that it prints at least one digit after the decimal point.</td></tr>
</table>
<h1><a class="toc-backref" id="limitations" href="#limitations">Limitations</a></h1><p>Because of the well defined order how templates and macros are expanded, strformat cannot expand template arguments:</p>
<p><pre class="listing"><span class="Keyword">template</span> <span class="Identifier">myTemplate</span><span class="Punctuation">(</span><span class="Identifier">arg</span><span class="Punctuation">:</span> <span class="Identifier">untyped</span><span class="Punctuation">)</span><span class="Punctuation">:</span> <span class="Identifier">untyped</span> <span class="Operator">=</span>
  <span class="Identifier">echo</span> <span class="StringLit">&quot;arg is: &quot;</span><span class="Punctuation">,</span> <span class="Identifier">arg</span>
  <span class="Identifier">echo</span> <span class="Operator">&amp;</span><span class="StringLit">&quot;--- {arg} ---&quot;</span>

<span class="Keyword">let</span> <span class="Identifier">x</span> <span class="Operator">=</span> <span class="StringLit">&quot;abc&quot;</span>
<span class="Identifier">myTemplate</span><span class="Punctuation">(</span><span class="Identifier">x</span><span class="Punctuation">)</span></pre></p>
<p>First the template <tt class="docutils literal"><span class="pre"><span class="Identifier">myTemplate</span></span></tt> is expanded, where every identifier <tt class="docutils literal"><span class="pre"><span class="Identifier">arg</span></span></tt> is substituted with its argument. The <tt class="docutils literal"><span class="pre"><span class="Identifier">arg</span></span></tt> inside the format string is not seen by this process, because it is part of a quoted string literal. It is not an identifier yet. Then the strformat macro creates the <tt class="docutils literal"><span class="pre"><span class="Identifier">arg</span></span></tt> identifier from the string literal, an identifier that cannot be resolved anymore.</p>
<p>The workaround for this is to bind the template argument to a new local variable.</p>
<p><pre class="listing"><span class="Keyword">template</span> <span class="Identifier">myTemplate</span><span class="Punctuation">(</span><span class="Identifier">arg</span><span class="Punctuation">:</span> <span class="Identifier">untyped</span><span class="Punctuation">)</span><span class="Punctuation">:</span> <span class="Identifier">untyped</span> <span class="Operator">=</span>
  <span class="Keyword">block</span><span class="Punctuation">:</span>
    <span class="Keyword">let</span> <span class="Identifier">arg1</span> <span class="Punctuation">{</span><span class="Operator">.</span><span class="Identifier">inject</span><span class="Operator">.</span><span class="Punctuation">}</span> <span class="Operator">=</span> <span class="Identifier">arg</span>
    <span class="Identifier">echo</span> <span class="StringLit">&quot;arg is: &quot;</span><span class="Punctuation">,</span> <span class="Identifier">arg1</span>
    <span class="Identifier">echo</span> <span class="Operator">&amp;</span><span class="StringLit">&quot;--- {arg1} ---&quot;</span></pre></p>
<p>The use of <tt class="docutils literal"><span class="pre"><span class="Punctuation">{</span><span class="Operator">.</span><span class="Identifier">inject</span><span class="Operator">.</span><span class="Punctuation">}</span></span></tt> here is necessary again because of template expansion order and hygienic templates. But since we generally want to keep the hygiene of <tt class="docutils literal"><span class="pre"><span class="Identifier">myTemplate</span></span></tt>, and we do not want <tt class="docutils literal"><span class="pre"><span class="Identifier">arg1</span></span></tt> to be injected into the context where <tt class="docutils literal"><span class="pre"><span class="Identifier">myTemplate</span></span></tt> is expanded, everything is wrapped in a <tt class="docutils literal"><span class="pre"><span class="Keyword">block</span></span></tt>.</p>

<h1><a class="toc-backref" id="future-directions" href="#future-directions">Future directions</a></h1><p>A curly expression with commas in it like <tt class="docutils literal"><span class="pre"><span class="Punctuation">{</span><span class="Identifier">x</span><span class="Punctuation">,</span> <span class="Identifier">argA</span><span class="Punctuation">,</span> <span class="Identifier">argB</span><span class="Punctuation">}</span></span></tt> could be transformed to <tt class="docutils literal"><span class="pre"><span class="Identifier">formatValue</span><span class="Punctuation">(</span><span class="Identifier">result</span><span class="Punctuation">,</span> <span class="Identifier">x</span><span class="Punctuation">,</span> <span class="Identifier">argA</span><span class="Punctuation">,</span> <span class="Identifier">argB</span><span class="Punctuation">)</span></span></tt> in order to support formatters that do not need to parse a custom language within a custom language but instead prefer to use Nim's existing syntax. This would also help with readability, since there is only so much you can cram into single letter DSLs. </p>
</p>
    <div class="section" id="6">
  <h1><a class="toc-backref" href="#6">Imports</a></h1>
  <dl class="item">
    <a class="reference external" href="macros.html">macros</a>, <a class="reference external" href="parseutils.html">parseutils</a>, <a class="reference external" href="unicode.html">unicode</a>, <a class="reference external" href="strutils.html">strutils</a>, <a class="reference external" href="assertions.html">assertions</a>
  </dl>
</div>
<div class="section" id="7">
  <h1><a class="toc-backref" href="#7">Types</a></h1>
  <dl class="item">
    <div id="StandardFormatSpecifier">
  <dt><pre><a href="strformat.html#StandardFormatSpecifier"><span class="Identifier">StandardFormatSpecifier</span></a> <span class="Other">=</span> <span class="Keyword">object</span>
  <span class="Identifier">fill</span><span class="Operator">*</span><span class="Other">,</span> <span class="Identifier">align</span><span class="Operator">*</span><span class="Other">:</span> <a href="system.html#char"><span class="Identifier">char</span></a>        <span class="Comment">## Desired fill and alignment.</span>
  <span class="Identifier">sign</span><span class="Operator">*</span><span class="Other">:</span> <a href="system.html#char"><span class="Identifier">char</span></a>                <span class="Comment">## Desired sign.</span>
  <span class="Identifier">alternateForm</span><span class="Operator">*</span><span class="Other">:</span> <a href="system.html#bool"><span class="Identifier">bool</span></a>       <span class="Comment">## Whether to prefix binary, octal and hex numbers</span>
                             <span class="Comment">## with `0b`, `0o`, `0x`.</span>
  <span class="Identifier">padWithZero</span><span class="Operator">*</span><span class="Other">:</span> <a href="system.html#bool"><span class="Identifier">bool</span></a>         <span class="Comment">## Whether to pad with zeros rather than spaces.</span>
  <span class="Identifier">minimumWidth</span><span class="Operator">*</span><span class="Other">,</span> <span class="Identifier">precision</span><span class="Operator">*</span><span class="Other">:</span> <a href="system.html#int"><span class="Identifier">int</span></a> <span class="Comment">## Desired minimum width and precision.</span>
  <span class="Identifier">typ</span><span class="Operator">*</span><span class="Other">:</span> <a href="system.html#char"><span class="Identifier">char</span></a>                 <span class="Comment">## Type like 'f', 'g' or 'd'.</span>
  <span class="Identifier">endPosition</span><span class="Operator">*</span><span class="Other">:</span> <a href="system.html#int"><span class="Identifier">int</span></a>          <span class="Comment">## End position in the format specifier after</span>
                             <span class="Comment">## `parseStandardFormatSpecifier` returned.</span></pre></dt>
  <dd>
    
    Type that describes &quot;standard format specifiers&quot;.
    <a href="https://github.com/nim-lang/Nim/tree/devel/lib/pure/strformat.nim#L359" class="link-seesrc" target="_blank">Source</a>&nbsp;&nbsp;
<a href="https://github.com/nim-lang/Nim/edit/devel/lib/pure/strformat.nim#L359" class="link-seesrc" target="_blank" >Edit</a>&nbsp;&nbsp;

  </dd>
</div>

  </dl>
</div>
<div class="section" id="12">
  <h1><a class="toc-backref" href="#12">Procs</a></h1>
  <dl class="item">
    <div id="alignString-procs-all">
  <div id="alignString,string,int,char,char">
  <dt><pre><span class="Keyword">proc</span> <a href="#alignString%2Cstring%2Cint%2Cchar%2Cchar"><span class="Identifier">alignString</span></a><span class="Other">(</span><span class="Identifier">s</span><span class="Other">:</span> <a href="system.html#string"><span class="Identifier">string</span></a><span class="Other">;</span> <span class="Identifier">minimumWidth</span><span class="Other">:</span> <a href="system.html#int"><span class="Identifier">int</span></a><span class="Other">;</span> <span class="Identifier">align</span> <span class="Other">=</span> <span class="CharLit">'\x00'</span><span class="Other">;</span> <span class="Identifier">fill</span> <span class="Other">=</span> <span class="CharLit">' '</span><span class="Other">)</span><span class="Other">:</span> <a href="system.html#string"><span class="Identifier">string</span></a> {.
    <span><span class="Other pragmadots">...</span></span><span class="pragmawrap"><span class="Identifier">raises</span><span class="Other">:</span> <span class="Other">[</span><span class="Other">]</span><span class="Other">,</span> <span class="Identifier">tags</span><span class="Other">:</span> <span class="Other">[</span><span class="Other">]</span><span class="Other">,</span> <span class="Identifier">forbids</span><span class="Other">:</span> <span class="Other">[</span><span class="Other">]</span></span>.}</pre></dt>
  <dd>
    
    Aligns <tt class="docutils literal"><span class="pre"><span class="Identifier">s</span></span></tt> using the <tt class="docutils literal"><span class="pre"><span class="Identifier">fill</span></span></tt> char. This is only of interest if you want to write a custom <tt class="docutils literal"><span class="pre"><span class="Identifier">format</span></span></tt> proc that should support the standard format specifiers.
    <a href="https://github.com/nim-lang/Nim/tree/devel/lib/pure/strformat.nim#L339" class="link-seesrc" target="_blank">Source</a>&nbsp;&nbsp;
<a href="https://github.com/nim-lang/Nim/edit/devel/lib/pure/strformat.nim#L339" class="link-seesrc" target="_blank" >Edit</a>&nbsp;&nbsp;

  </dd>
</div>

</div>
<div id="formatValue-procs-all">
  <div id="formatValue,string,SomeFloat,staticstring">
  <dt><pre><span class="Keyword">proc</span> <a href="#formatValue%2Cstring%2CSomeFloat%2Cstaticstring"><span class="Identifier">formatValue</span></a><span class="Other">(</span><span class="Identifier">result</span><span class="Other">:</span> <span class="Keyword">var</span> <a href="system.html#string"><span class="Identifier">string</span></a><span class="Other">;</span> <span class="Identifier">value</span><span class="Other">:</span> <a href="system.html#SomeFloat"><span class="Identifier">SomeFloat</span></a><span class="Other">;</span> <span class="Identifier">specifier</span><span class="Other">:</span> <a href="system.html#static"><span class="Identifier">static</span></a> <span class="Identifier">string</span><span class="Other">)</span></pre></dt>
  <dd>
    
    Standard format implementation for <tt class="docutils literal"><span class="pre"><span class="Identifier">SomeFloat</span></span></tt>. It makes little sense to call this directly, but it is required to exist by the <tt class="docutils literal"><span class="pre"><span class="Operator">&amp;</span></span></tt> macro.
    <a href="https://github.com/nim-lang/Nim/tree/devel/lib/pure/strformat.nim#L569" class="link-seesrc" target="_blank">Source</a>&nbsp;&nbsp;
<a href="https://github.com/nim-lang/Nim/edit/devel/lib/pure/strformat.nim#L569" class="link-seesrc" target="_blank" >Edit</a>&nbsp;&nbsp;

  </dd>
</div>
<div id="formatValue,string,SomeFloat,string">
  <dt><pre><span class="Keyword">proc</span> <a href="#formatValue%2Cstring%2CSomeFloat%2Cstring"><span class="Identifier">formatValue</span></a><span class="Other">(</span><span class="Identifier">result</span><span class="Other">:</span> <span class="Keyword">var</span> <a href="system.html#string"><span class="Identifier">string</span></a><span class="Other">;</span> <span class="Identifier">value</span><span class="Other">:</span> <a href="system.html#SomeFloat"><span class="Identifier">SomeFloat</span></a><span class="Other">;</span> <span class="Identifier">specifier</span><span class="Other">:</span> <a href="system.html#string"><span class="Identifier">string</span></a><span class="Other">)</span></pre></dt>
  <dd>
    
    Standard format implementation for <tt class="docutils literal"><span class="pre"><span class="Identifier">SomeFloat</span></span></tt>. It makes little sense to call this directly, but it is required to exist by the <tt class="docutils literal"><span class="pre"><span class="Operator">&amp;</span></span></tt> macro.
    <a href="https://github.com/nim-lang/Nim/tree/devel/lib/pure/strformat.nim#L582" class="link-seesrc" target="_blank">Source</a>&nbsp;&nbsp;
<a href="https://github.com/nim-lang/Nim/edit/devel/lib/pure/strformat.nim#L582" class="link-seesrc" target="_blank" >Edit</a>&nbsp;&nbsp;

  </dd>
</div>
<div id="formatValue,string,string,staticstring">
  <dt><pre><span class="Keyword">proc</span> <a href="#formatValue%2Cstring%2Cstring%2Cstaticstring"><span class="Identifier">formatValue</span></a><span class="Other">(</span><span class="Identifier">result</span><span class="Other">:</span> <span class="Keyword">var</span> <a href="system.html#string"><span class="Identifier">string</span></a><span class="Other">;</span> <span class="Identifier">value</span><span class="Other">:</span> <a href="system.html#string"><span class="Identifier">string</span></a><span class="Other">;</span> <span class="Identifier">specifier</span><span class="Other">:</span> <a href="system.html#static"><span class="Identifier">static</span></a> <span class="Identifier">string</span><span class="Other">)</span></pre></dt>
  <dd>
    
    Standard format implementation for <tt class="docutils literal"><span class="pre"><span class="Identifier">string</span></span></tt>. It makes little sense to call this directly, but it is required to exist by the <tt class="docutils literal"><span class="pre"><span class="Operator">&amp;</span></span></tt> macro.
    <a href="https://github.com/nim-lang/Nim/tree/devel/lib/pure/strformat.nim#L595" class="link-seesrc" target="_blank">Source</a>&nbsp;&nbsp;
<a href="https://github.com/nim-lang/Nim/edit/devel/lib/pure/strformat.nim#L595" class="link-seesrc" target="_blank" >Edit</a>&nbsp;&nbsp;

  </dd>
</div>
<div id="formatValue,string,string,string">
  <dt><pre><span class="Keyword">proc</span> <a href="#formatValue%2Cstring%2Cstring%2Cstring"><span class="Identifier">formatValue</span></a><span class="Other">(</span><span class="Identifier">result</span><span class="Other">:</span> <span class="Keyword">var</span> <a href="system.html#string"><span class="Identifier">string</span></a><span class="Other">;</span> <span class="Identifier">value</span><span class="Other">:</span> <a href="system.html#string"><span class="Identifier">string</span></a><span class="Other">;</span> <span class="Identifier">specifier</span><span class="Other">:</span> <a href="system.html#string"><span class="Identifier">string</span></a><span class="Other">)</span> {.
    <span><span class="Other pragmadots">...</span></span><span class="pragmawrap"><span class="Identifier">raises</span><span class="Other">:</span> <span class="Other">[</span><span class="Identifier">ValueError</span><span class="Other">]</span><span class="Other">,</span> <span class="Identifier">tags</span><span class="Other">:</span> <span class="Other">[</span><span class="Other">]</span><span class="Other">,</span> <span class="Identifier">forbids</span><span class="Other">:</span> <span class="Other">[</span><span class="Other">]</span></span>.}</pre></dt>
  <dd>
    
    Standard format implementation for <tt class="docutils literal"><span class="pre"><span class="Identifier">string</span></span></tt>. It makes little sense to call this directly, but it is required to exist by the <tt class="docutils literal"><span class="pre"><span class="Operator">&amp;</span></span></tt> macro.
    <a href="https://github.com/nim-lang/Nim/tree/devel/lib/pure/strformat.nim#L613" class="link-seesrc" target="_blank">Source</a>&nbsp;&nbsp;
<a href="https://github.com/nim-lang/Nim/edit/devel/lib/pure/strformat.nim#L613" class="link-seesrc" target="_blank" >Edit</a>&nbsp;&nbsp;

  </dd>
</div>
<div id="formatValue,string,T,staticstring">
  <dt><pre><span class="Keyword">proc</span> <a href="#formatValue%2Cstring%2CT%2Cstaticstring"><span class="Identifier">formatValue</span></a><span class="Other">[</span><span class="Identifier">T</span><span class="Other">:</span> <a href="system.html#SomeInteger"><span class="Identifier">SomeInteger</span></a><span class="Other">]</span><span class="Other">(</span><span class="Identifier">result</span><span class="Other">:</span> <span class="Keyword">var</span> <a href="system.html#string"><span class="Identifier">string</span></a><span class="Other">;</span> <span class="Identifier">value</span><span class="Other">:</span> <span class="Identifier">T</span><span class="Other">;</span>
                                 <span class="Identifier">specifier</span><span class="Other">:</span> <a href="system.html#static"><span class="Identifier">static</span></a> <span class="Identifier">string</span><span class="Other">)</span></pre></dt>
  <dd>
    
    Standard format implementation for <tt class="docutils literal"><span class="pre"><span class="Identifier">SomeInteger</span></span></tt>. It makes little sense to call this directly, but it is required to exist by the <tt class="docutils literal"><span class="pre"><span class="Operator">&amp;</span></span></tt> macro.
    <a href="https://github.com/nim-lang/Nim/tree/devel/lib/pure/strformat.nim#L493" class="link-seesrc" target="_blank">Source</a>&nbsp;&nbsp;
<a href="https://github.com/nim-lang/Nim/edit/devel/lib/pure/strformat.nim#L493" class="link-seesrc" target="_blank" >Edit</a>&nbsp;&nbsp;

  </dd>
</div>
<div id="formatValue,string,T,string">
  <dt><pre><span class="Keyword">proc</span> <a href="#formatValue%2Cstring%2CT%2Cstring"><span class="Identifier">formatValue</span></a><span class="Other">[</span><span class="Identifier">T</span><span class="Other">:</span> <a href="system.html#SomeInteger"><span class="Identifier">SomeInteger</span></a><span class="Other">]</span><span class="Other">(</span><span class="Identifier">result</span><span class="Other">:</span> <span class="Keyword">var</span> <a href="system.html#string"><span class="Identifier">string</span></a><span class="Other">;</span> <span class="Identifier">value</span><span class="Other">:</span> <span class="Identifier">T</span><span class="Other">;</span> <span class="Identifier">specifier</span><span class="Other">:</span> <a href="system.html#string"><span class="Identifier">string</span></a><span class="Other">)</span></pre></dt>
  <dd>
    
    Standard format implementation for <tt class="docutils literal"><span class="pre"><span class="Identifier">SomeInteger</span></span></tt>. It makes little sense to call this directly, but it is required to exist by the <tt class="docutils literal"><span class="pre"><span class="Operator">&amp;</span></span></tt> macro.
    <a href="https://github.com/nim-lang/Nim/tree/devel/lib/pure/strformat.nim#L507" class="link-seesrc" target="_blank">Source</a>&nbsp;&nbsp;
<a href="https://github.com/nim-lang/Nim/edit/devel/lib/pure/strformat.nim#L507" class="link-seesrc" target="_blank" >Edit</a>&nbsp;&nbsp;

  </dd>
</div>

</div>
<div id="parseStandardFormatSpecifier-procs-all">
  <div id="parseStandardFormatSpecifier,string,int">
  <dt><pre><span class="Keyword">proc</span> <a href="#parseStandardFormatSpecifier%2Cstring%2Cint"><span class="Identifier">parseStandardFormatSpecifier</span></a><span class="Other">(</span><span class="Identifier">s</span><span class="Other">:</span> <a href="system.html#string"><span class="Identifier">string</span></a><span class="Other">;</span> <span class="Identifier">start</span> <span class="Other">=</span> <span class="DecNumber">0</span><span class="Other">;</span>
                                  <span class="Identifier">ignoreUnknownSuffix</span> <span class="Other">=</span> <span class="Identifier">false</span><span class="Other">)</span><span class="Other">:</span> <a href="strformat.html#StandardFormatSpecifier"><span class="Identifier">StandardFormatSpecifier</span></a> {.
    <span><span class="Other pragmadots">...</span></span><span class="pragmawrap"><span class="Identifier">raises</span><span class="Other">:</span> <span class="Other">[</span><span class="Identifier">ValueError</span><span class="Other">]</span><span class="Other">,</span> <span class="Identifier">tags</span><span class="Other">:</span> <span class="Other">[</span><span class="Other">]</span><span class="Other">,</span> <span class="Identifier">forbids</span><span class="Other">:</span> <span class="Other">[</span><span class="Other">]</span></span>.}</pre></dt>
  <dd>
    
    An exported helper proc that parses the &quot;standard format specifiers&quot;, as specified by the grammar:<pre>[[fill]align][sign][#][0][minimumwidth][.precision][type]</pre>
<p>This is only of interest if you want to write a custom <tt class="docutils literal"><span class="pre"><span class="Identifier">format</span></span></tt> proc that should support the standard format specifiers. If <tt class="docutils literal"><span class="pre"><span class="Identifier">ignoreUnknownSuffix</span></span></tt> is true, an unknown suffix after the <tt class="docutils literal"><span class="pre"><span class="Keyword">type</span></span></tt> field is not an error.</p>

    <a href="https://github.com/nim-lang/Nim/tree/devel/lib/pure/strformat.nim#L432" class="link-seesrc" target="_blank">Source</a>&nbsp;&nbsp;
<a href="https://github.com/nim-lang/Nim/edit/devel/lib/pure/strformat.nim#L432" class="link-seesrc" target="_blank" >Edit</a>&nbsp;&nbsp;

  </dd>
</div>

</div>

  </dl>
</div>
<div class="section" id="18">
  <h1><a class="toc-backref" href="#18">Templates</a></h1>
  <dl class="item">
    <div id="&amp;-templates-all">
  <div id="&.t">
  <dt><pre><span class="Keyword">template</span> <a href="#%26.t"><span class="Identifier">`&amp;`</span></a><span class="Other">(</span><span class="Identifier">pattern</span><span class="Other">:</span> <a href="system.html#string"><span class="Identifier">string</span></a><span class="Other">{</span><span class="Identifier">lit</span><span class="Other">}</span><span class="Other">)</span><span class="Other">:</span> <a href="system.html#string"><span class="Identifier">string</span></a> {.<span class="Identifier">callsite</span>.}</pre></dt>
  <dd>
    
    <tt class="docutils literal"><span class="pre"><span class="Operator">&amp;</span><span class="Identifier">pattern</span></span></tt> is the same as <tt class="docutils literal"><span class="pre"><span class="Identifier">pattern</span><span class="Operator">.</span><span class="Identifier">fmt</span></span></tt>. For a specification of the <tt class="docutils literal"><span class="pre"><span class="Operator">&amp;</span></span></tt> macro, see the module level documentation.
<p><strong class="examples_text">Example:</strong></p>
<pre class="listing"><span class="Keyword">let</span> <span class="Identifier">x</span> <span class="Operator">=</span> <span class="DecNumber">7</span>
<span class="Identifier">assert</span> <span class="Operator">&amp;</span><span class="StringLit">&quot;{x}</span><span class="EscapeSequence">\n</span><span class="StringLit">&quot;</span> <span class="Operator">==</span> <span class="StringLit">&quot;7</span><span class="EscapeSequence">\n</span><span class="StringLit">&quot;</span> <span class="Comment"># regular string literal</span>
<span class="Identifier">assert</span> <span class="Operator">&amp;</span><span class="StringLit">&quot;{x}</span><span class="EscapeSequence">\n</span><span class="StringLit">&quot;</span> <span class="Operator">==</span> <span class="StringLit">&quot;{x}</span><span class="EscapeSequence">\n</span><span class="StringLit">&quot;</span><span class="Operator">.</span><span class="Identifier">fmt</span> <span class="Comment"># `fmt` can be used instead</span>
<span class="Identifier">assert</span> <span class="Operator">&amp;</span><span class="StringLit">&quot;{x}</span><span class="EscapeSequence">\n</span><span class="StringLit">&quot;</span> <span class="Operator">!=</span> <span class="RawData">fmt&quot;{x}\n&quot;</span> <span class="Comment"># see `fmt` docs, this would use a raw string literal</span></pre>
    <a href="https://github.com/nim-lang/Nim/tree/devel/lib/pure/strformat.nim#L776" class="link-seesrc" target="_blank">Source</a>&nbsp;&nbsp;
<a href="https://github.com/nim-lang/Nim/edit/devel/lib/pure/strformat.nim#L776" class="link-seesrc" target="_blank" >Edit</a>&nbsp;&nbsp;

  </dd>
</div>

</div>
<div id="fmt-templates-all">
  <div id="fmt.t,staticstring">
  <dt><pre><span class="Keyword">template</span> <a href="#fmt.t%2Cstaticstring"><span class="Identifier">fmt</span></a><span class="Other">(</span><span class="Identifier">pattern</span><span class="Other">:</span> <a href="system.html#static"><span class="Identifier">static</span></a> <span class="Identifier">string</span><span class="Other">)</span><span class="Other">:</span> <a href="system.html#untyped"><span class="Identifier">untyped</span></a> {.<span class="Identifier">callsite</span>.}</pre></dt>
  <dd>
    
    Alias for <tt class="docutils literal"><span class="pre"><span class="Identifier">fmt</span><span class="Punctuation">(</span><span class="Identifier">pattern</span><span class="Punctuation">,</span> <span class="CharLit">'{'</span><span class="Punctuation">,</span> <span class="CharLit">'}'</span><span class="Punctuation">)</span></span></tt>.
    <a href="https://github.com/nim-lang/Nim/tree/devel/lib/pure/strformat.nim#L772" class="link-seesrc" target="_blank">Source</a>&nbsp;&nbsp;
<a href="https://github.com/nim-lang/Nim/edit/devel/lib/pure/strformat.nim#L772" class="link-seesrc" target="_blank" >Edit</a>&nbsp;&nbsp;

  </dd>
</div>
<div id="fmt.t,staticstring,staticchar,staticchar">
  <dt><pre><span class="Keyword">template</span> <a href="#fmt.t%2Cstaticstring%2Cstaticchar%2Cstaticchar"><span class="Identifier">fmt</span></a><span class="Other">(</span><span class="Identifier">pattern</span><span class="Other">:</span> <a href="system.html#static"><span class="Identifier">static</span></a> <span class="Identifier">string</span><span class="Other">;</span> <span class="Identifier">openChar</span><span class="Other">:</span> <a href="system.html#static"><span class="Identifier">static</span></a> <span class="Identifier">char</span><span class="Other">;</span>
             <span class="Identifier">closeChar</span><span class="Other">:</span> <a href="system.html#static"><span class="Identifier">static</span></a> <span class="Identifier">char</span><span class="Other">)</span><span class="Other">:</span> <a href="system.html#string"><span class="Identifier">string</span></a> {.<span class="Identifier">callsite</span>.}</pre></dt>
  <dd>
    
    Interpolates <tt class="docutils literal"><span class="pre"><span class="Identifier">pattern</span></span></tt> using symbols in scope.
<p><strong class="examples_text">Example:</strong></p>
<pre class="listing"><span class="Keyword">let</span> <span class="Identifier">x</span> <span class="Operator">=</span> <span class="DecNumber">7</span>
<span class="Identifier">assert</span> <span class="StringLit">&quot;var is {x * 2}&quot;</span><span class="Operator">.</span><span class="Identifier">fmt</span> <span class="Operator">==</span> <span class="StringLit">&quot;var is 14&quot;</span>
<span class="Identifier">assert</span> <span class="StringLit">&quot;var is {{x}}&quot;</span><span class="Operator">.</span><span class="Identifier">fmt</span> <span class="Operator">==</span> <span class="StringLit">&quot;var is {x}&quot;</span> <span class="Comment"># escape via doubling</span>
<span class="Keyword">const</span> <span class="Identifier">s</span> <span class="Operator">=</span> <span class="StringLit">&quot;foo: {x}&quot;</span>
<span class="Identifier">assert</span> <span class="Identifier">s</span><span class="Operator">.</span><span class="Identifier">fmt</span> <span class="Operator">==</span> <span class="StringLit">&quot;foo: 7&quot;</span> <span class="Comment"># also works with const strings</span>

<span class="Identifier">assert</span> <span class="RawData">fmt&quot;\n&quot;</span> <span class="Operator">==</span> <span class="RawData">r&quot;\n&quot;</span> <span class="Comment"># raw string literal</span>
<span class="Identifier">assert</span> <span class="StringLit">&quot;</span><span class="EscapeSequence">\n</span><span class="StringLit">&quot;</span><span class="Operator">.</span><span class="Identifier">fmt</span> <span class="Operator">==</span> <span class="StringLit">&quot;</span><span class="EscapeSequence">\n</span><span class="StringLit">&quot;</span> <span class="Comment"># regular literal (likewise with `fmt(&quot;\n&quot;)` or `fmt &quot;\n&quot;`)</span></pre>
<p><strong class="examples_text">Example:</strong></p>
<pre class="listing"><span class="Comment"># custom `openChar`, `closeChar`</span>
<span class="Keyword">let</span> <span class="Identifier">x</span> <span class="Operator">=</span> <span class="DecNumber">7</span>
<span class="Identifier">assert</span> <span class="StringLit">&quot;&lt;x&gt;&quot;</span><span class="Operator">.</span><span class="Identifier">fmt</span><span class="Punctuation">(</span><span class="Punctuation">'</span><span class="Operator">&lt;</span><span class="CharLit">', '</span><span class="Operator">&gt;</span><span class="CharLit">') == &quot;7&quot;</span>
<span class="Identifier">assert</span> <span class="StringLit">&quot;&lt;&lt;&lt;x&gt;&gt;&gt;&quot;</span><span class="Operator">.</span><span class="Identifier">fmt</span><span class="Punctuation">(</span><span class="Punctuation">'</span><span class="Operator">&lt;</span><span class="CharLit">', '</span><span class="Operator">&gt;</span><span class="CharLit">') == &quot;&lt;7&gt;&quot;</span>
<span class="Identifier">assert</span> <span class="StringLit">&quot;`x`&quot;</span><span class="Operator">.</span><span class="Identifier">fmt</span><span class="Punctuation">(</span><span class="Punctuation">'</span><span class="Punctuation">`</span><span class="Punctuation">'</span><span class="Punctuation">,</span> <span class="CharLit">'`'</span><span class="Punctuation">)</span> <span class="Operator">==</span> <span class="StringLit">&quot;7&quot;</span></pre>
    <a href="https://github.com/nim-lang/Nim/tree/devel/lib/pure/strformat.nim#L753" class="link-seesrc" target="_blank">Source</a>&nbsp;&nbsp;
<a href="https://github.com/nim-lang/Nim/edit/devel/lib/pure/strformat.nim#L753" class="link-seesrc" target="_blank" >Edit</a>&nbsp;&nbsp;

  </dd>
</div>

</div>

  </dl>
</div>

  </div>
</div>

      <div class="twelve-columns footer">
        <span class="nim-sprite"></span>
        <br>
        <small style="color: var(--hint);">Made with Nim. Generated: 2025-04-03 14:18:37 UTC</small>
      </div>
    </div>
  </div>
      <script defer data-domain="nim-lang.org" src="https://plausible.io/js/plausible.js"></script>
    
</body>
</html>