doc/guide/localhost/InfixingOperators

   1 <!DOCTYPE html>
   2 <html lang="en">
   3 <head>
   4 <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
   5 <meta name="generator" content="AsciiDoc 8.6.9">
   6 <title>InfixingOperators</title>
   7 <link rel="stylesheet" href="./asciidoc.css" type="text/css">
   8 <link rel="stylesheet" href="./pygments.css" type="text/css">
   9
  10
  11 <script type="text/javascript" src="./asciidoc.js"></script>
  12 <script type="text/javascript">
  13 /*<![CDATA[*/
  14 asciidoc.install();
  15 /*]]>*/
  16 </script>
  17 <link rel="stylesheet" href="./mlton.css" type="text/css">
  18 </head>
  19 <body class="article">
  20 <div id="banner">
  21 <div id="banner-home">
  22 <a href="./Home">MLton 20180207</a>
  23 </div>
  24 </div>
  25 <div id="header">
  26 <h1>InfixingOperators</h1>
  27 </div>
  28 <div id="content">
  29 <div id="preamble">
  30 <div class="sectionbody">
  31 <div class="paragraph"><p>Fixity specifications are not part of signatures in
  32 <a href="StandardML">Standard ML</a>. When one wants to use a module that
  33 provides functions designed to be used as infix operators there are
  34 several obvious alternatives:</p></div>
  35 <div class="ulist"><ul>
  36 <li>
  37 <p>
  38 Use only prefix applications. Unfortunately there are situations
  39 where infix applications lead to considerably more readable code.
  40 </p>
  41 </li>
  42 <li>
  43 <p>
  44 Make the fixity declarations at the top-level. This may lead to
  45 collisions and may be unsustainable in a large project. Pollution of
  46 the top-level should be avoided.
  47 </p>
  48 </li>
  49 <li>
  50 <p>
  51 Make the fixity declarations at each scope where you want to use
  52 infix applications. The duplication becomes inconvenient if the
  53 operators are widely used. Duplication of code should be avoided.
  54 </p>
  55 </li>
  56 <li>
  57 <p>
  58 Use non-standard extensions, such as the <a href="MLBasis"> ML Basis system</a>
  59 to control the scope of fixity declarations. This has the obvious
  60 drawback of reduced portability.
  61 </p>
  62 </li>
  63 <li>
  64 <p>
  65 Reuse existing infix operator symbols (<span class="monospaced">^</span>, <span class="monospaced">+</span>, <span class="monospaced">-</span>, &#8230;).  This
  66 can be convenient when the standard operators aren&#8217;t needed in the
  67 same scope with the new operators.  On the other hand, one is limited
  68 to the standard operator symbols and the code may appear confusing.
  69 </p>
  70 </li>
  71 </ul></div>
  72 <div class="paragraph"><p>None of the obvious alternatives is best in every case. The following
  73 describes a slightly less obvious alternative that can sometimes be
  74 useful. The idea is to approximate Haskell&#8217;s special syntax for
  75 treating any identifier enclosed in grave accents (backquotes) as an
  76 infix operator. In Haskell, instead of writing the prefix application
  77 <span class="monospaced">f x y</span> one can write the infix application <span class="monospaced">x &grave;f&grave; y</span>.</p></div>
  78 </div>
  79 </div>
  80 <div class="sect1">
  81 <h2 id="_infixing_operators">Infixing operators</h2>
  82 <div class="sectionbody">
  83 <div class="paragraph"><p>Let&#8217;s first take a look at the definitions of the operators:</p></div>
  84 <div class="listingblock">
  85 <div class="content"><div class="highlight"><pre><span class="k">infix</span><span class="w">  </span><span class="mi">3</span><span class="w"> </span><span class="n">&lt;\</span><span class="w">     </span><span class="k">fun</span><span class="w"> </span><span class="n">x</span><span class="w"> </span><span class="n">&lt;\</span><span class="w"> </span><span class="n">f</span><span class="w"> </span><span class="p">=</span><span class="w"> </span><span class="k">fn</span><span class="w"> </span><span class="n">y</span><span class="w"> </span><span class="p">=&gt;</span><span class="w"> </span><span class="n">f</span><span class="w"> </span><span class="p">(</span><span class="n">x</span><span class="p">,</span><span class="w"> </span><span class="n">y</span><span class="p">)</span><span class="w">     </span><span class="cm">(* Left section      *)</span><span class="w"></span>
  86 <span class="k">infix</span><span class="w">  </span><span class="mi">3</span><span class="w"> </span><span class="n">\&gt;</span><span class="w">     </span><span class="k">fun</span><span class="w"> </span><span class="n">f</span><span class="w"> </span><span class="n">\&gt;</span><span class="w"> </span><span class="n">y</span><span class="w"> </span><span class="p">=</span><span class="w"> </span><span class="n">f</span><span class="w"> </span><span class="n">y</span><span class="w">                  </span><span class="cm">(* Left application  *)</span><span class="w"></span>
  87 <span class="k">infixr</span><span class="w"> </span><span class="mi">3</span><span class="w"> </span><span class="n">/&gt;</span><span class="w">     </span><span class="k">fun</span><span class="w"> </span><span class="n">f</span><span class="w"> </span><span class="n">/&gt;</span><span class="w"> </span><span class="n">y</span><span class="w"> </span><span class="p">=</span><span class="w"> </span><span class="k">fn</span><span class="w"> </span><span class="n">x</span><span class="w"> </span><span class="p">=&gt;</span><span class="w"> </span><span class="n">f</span><span class="w"> </span><span class="p">(</span><span class="n">x</span><span class="p">,</span><span class="w"> </span><span class="n">y</span><span class="p">)</span><span class="w">     </span><span class="cm">(* Right section     *)</span><span class="w"></span>
  88 <span class="k">infixr</span><span class="w"> </span><span class="mi">3</span><span class="w"> </span><span class="n">&lt;/</span><span class="w">     </span><span class="k">fun</span><span class="w"> </span><span class="n">x</span><span class="w"> </span><span class="n">&lt;/</span><span class="w"> </span><span class="n">f</span><span class="w"> </span><span class="p">=</span><span class="w"> </span><span class="n">f</span><span class="w"> </span><span class="n">x</span><span class="w">                  </span><span class="cm">(* Right application *)</span><span class="w"></span>
  89
  90 <span class="k">infix</span><span class="w">  </span><span class="mi">2</span><span class="w"> </span><span class="n">o</span><span class="w">  </span><span class="cm">(* See motivation below *)</span><span class="w"></span>
  91 <span class="k">infix</span><span class="w">  </span><span class="mi">0</span><span class="w"> </span><span class="n">:=</span><span class="w"></span>
  92 </pre></div></div></div>
  93 <div class="paragraph"><p>The left and right sectioning operators, <span class="monospaced">&lt;\</span> and <span class="monospaced">/&gt;</span>, are useful in
  94 SML for partial application of infix operators.
  95 <a href="References#Paulson96"> ML For the Working Programmer</a> describes curried
  96 functions <span class="monospaced">secl</span> and <span class="monospaced">secr</span> for the same purpose on pages 179-181.
  97 For example,</p></div>
  98 <div class="listingblock">
  99 <div class="content"><div class="highlight"><pre><span class="n">List</span><span class="p">.</span><span class="n">map</span><span class="w"> </span><span class="p">(</span><span class="k">op</span><span class="n">-</span><span class="w"> </span><span class="n">/&gt;</span><span class="w"> </span><span class="n">y</span><span class="p">)</span><span class="w"></span>
 100 </pre></div></div></div>
 101 <div class="paragraph"><p>is a function for subtracting <span class="monospaced">y</span> from a list of integers and</p></div>
 102 <div class="listingblock">
 103 <div class="content"><div class="highlight"><pre><span class="n">List</span><span class="p">.</span><span class="n">exists</span><span class="w"> </span><span class="p">(</span><span class="n">x</span><span class="w"> </span><span class="n">&lt;\</span><span class="w"> </span><span class="k">op</span><span class="p">=)</span><span class="w"></span>
 104 </pre></div></div></div>
 105 <div class="paragraph"><p>is a function for testing whether a list contains an <span class="monospaced">x</span>.</p></div>
 106 <div class="paragraph"><p>Together with the left and right application operators, <span class="monospaced">\&gt;</span> and <span class="monospaced">&lt;/</span>,
 107 the sectioning operators provide a way to treat any binary function
 108 (i.e. a function whose domain is a pair) as an infix operator.  In
 109 general,</p></div>
 110 <div class="listingblock">
 111 <div class="content monospaced">
 112 <pre>x0 &lt;\f1\&gt; x1 &lt;\f2\&gt; x2 ... &lt;\fN\&gt; xN = fN (... f2 (f1 (x0, x1), x2) ..., xN)</pre>
 113 </div></div>
 114 <div class="paragraph"><p>and</p></div>
 115 <div class="listingblock">
 116 <div class="content monospaced">
 117 <pre>xN &lt;/fN/&gt; ... x2 &lt;/f2/&gt; x1 &lt;/f1/&gt; x0  =  fN (xN, ... f2 (x2, f1 (x1, x0)) ...)</pre>
 118 </div></div>
 119 <div class="sect2">
 120 <h3 id="_examples">Examples</h3>
 121 <div class="paragraph"><p>As a fairly realistic example, consider providing a function for sequencing
 122 comparisons:</p></div>
 123 <div class="listingblock">
 124 <div class="content"><div class="highlight"><pre><span class="k">structure</span><span class="w"> </span><span class="n">Order</span><span class="w"> </span><span class="cm">(* ... *)</span><span class="w"> </span><span class="p">=</span><span class="w"></span>
 125 <span class="w">   </span><span class="k">struct</span><span class="w"></span>
 126 <span class="w">      </span><span class="cm">(* ... *)</span><span class="w"></span>
 127 <span class="w">      </span><span class="k">val</span><span class="w"> </span><span class="n">orWhenEq</span><span class="w"> </span><span class="p">=</span><span class="w"> </span><span class="k">fn</span><span class="w"> </span><span class="p">(</span><span class="n">EQUAL</span><span class="p">,</span><span class="w"> </span><span class="n">th</span><span class="p">)</span><span class="w"> </span><span class="p">=&gt;</span><span class="w"> </span><span class="n">th</span><span class="w"> </span><span class="p">()</span><span class="w"></span>
 128 <span class="w">                      </span><span class="p">|</span><span class="w"> </span><span class="p">(</span><span class="n">other</span><span class="p">,</span><span class="w">  </span><span class="p">_)</span><span class="w"> </span><span class="p">=&gt;</span><span class="w"> </span><span class="n">other</span><span class="w"></span>
 129 <span class="w">      </span><span class="cm">(* ... *)</span><span class="w"></span>
 130 <span class="w">   </span><span class="k">end</span><span class="w"></span>
 131 </pre></div></div></div>
 132 <div class="paragraph"><p>Using <span class="monospaced">orWhenEq</span> and the infixing operators, one can write a
 133 <span class="monospaced">compare</span> function for triples as</p></div>
 134 <div class="listingblock">
 135 <div class="content"><div class="highlight"><pre><span class="k">fun</span><span class="w"> </span><span class="n">compare</span><span class="w"> </span><span class="p">(</span><span class="n">fad</span><span class="p">,</span><span class="w"> </span><span class="n">fbe</span><span class="p">,</span><span class="w"> </span><span class="n">fcf</span><span class="p">)</span><span class="w"> </span><span class="p">((</span><span class="n">a</span><span class="p">,</span><span class="w"> </span><span class="n">b</span><span class="p">,</span><span class="w"> </span><span class="n">c</span><span class="p">),</span><span class="w"> </span><span class="p">(</span><span class="n">d</span><span class="p">,</span><span class="w"> </span><span class="n">e</span><span class="p">,</span><span class="w"> </span><span class="n">f</span><span class="p">))</span><span class="w"> </span><span class="p">=</span><span class="w"></span>
 136 <span class="w">    </span><span class="n">fad</span><span class="w"> </span><span class="p">(</span><span class="n">a</span><span class="p">,</span><span class="w"> </span><span class="n">d</span><span class="p">)</span><span class="w"> </span><span class="n">&lt;\Order</span><span class="p">.</span><span class="n">orWhenEq\&gt;</span><span class="w"> </span><span class="n">`fbe</span><span class="w"> </span><span class="p">(</span><span class="n">b</span><span class="p">,</span><span class="w"> </span><span class="n">e</span><span class="p">)</span><span class="w"> </span><span class="n">&lt;\Order</span><span class="p">.</span><span class="n">orWhenEq\&gt;</span><span class="w"> </span><span class="n">`fcf</span><span class="w"> </span><span class="p">(</span><span class="n">c</span><span class="p">,</span><span class="w"> </span><span class="n">f</span><span class="p">)</span><span class="w"></span>
 137 </pre></div></div></div>
 138 <div class="paragraph"><p>where <span class="monospaced">&grave;</span> is defined as</p></div>
 139 <div class="listingblock">
 140 <div class="content"><div class="highlight"><pre><span class="k">fun</span><span class="w"> </span><span class="n">`f</span><span class="w"> </span><span class="n">x</span><span class="w"> </span><span class="p">=</span><span class="w"> </span><span class="k">fn</span><span class="w"> </span><span class="p">()</span><span class="w"> </span><span class="p">=&gt;</span><span class="w"> </span><span class="n">f</span><span class="w"> </span><span class="n">x</span><span class="w"></span>
 141 </pre></div></div></div>
 142 <div class="paragraph"><p>Although <span class="monospaced">orWhenEq</span> can be convenient (try rewriting the above without
 143 it), it is probably not useful enough to be defined at the top level
 144 as an infix operator. Fortunately we can use the infixing operators
 145 and don&#8217;t have to.</p></div>
 146 <div class="paragraph"><p>Another fairly realistic example would be to use the infixing operators with
 147 the technique described on the <a href="Printf">Printf</a> page. Assuming that you would have
 148 a <span class="monospaced">Printf</span> module binding <span class="monospaced">printf</span>, <span class="monospaced">&grave;</span>, and formatting combinators
 149 named <span class="monospaced">int</span> and <span class="monospaced">string</span>, you could write</p></div>
 150 <div class="listingblock">
 151 <div class="content"><div class="highlight"><pre><span class="k">let</span><span class="w"> </span><span class="k">open</span><span class="w"> </span><span class="n">Printf</span><span class="w"> </span><span class="k">in</span><span class="w"></span>
 152 <span class="w">  </span><span class="n">printf</span><span class="w"> </span><span class="p">(</span><span class="n">`</span><span class="s">&quot;Here&#39;s an int &quot;</span><span class="n">&lt;\int\&gt;</span><span class="s">&quot; and a string &quot;</span><span class="n">&lt;\string\&gt;</span><span class="s">&quot;.&quot;</span><span class="p">)</span><span class="w"> </span><span class="mi">13</span><span class="w"> </span><span class="s">&quot;foo&quot;</span><span class="w"> </span><span class="k">end</span><span class="w"></span>
 153 </pre></div></div></div>
 154 <div class="paragraph"><p>without having to duplicate the fixity declarations. Alternatively, you could
 155 write</p></div>
 156 <div class="listingblock">
 157 <div class="content"><div class="highlight"><pre><span class="n">P</span><span class="p">.</span><span class="n">printf</span><span class="w"> </span><span class="p">(</span><span class="n">P</span><span class="p">.</span><span class="n">`</span><span class="s">&quot;Here&#39;s an int &quot;</span><span class="n">&lt;\P</span><span class="p">.</span><span class="n">int\&gt;</span><span class="s">&quot; and a string &quot;</span><span class="n">&lt;\P</span><span class="p">.</span><span class="n">string\&gt;</span><span class="s">&quot;.&quot;</span><span class="p">)</span><span class="w"> </span><span class="mi">13</span><span class="w"> </span><span class="s">&quot;foo&quot;</span><span class="w"></span>
 158 </pre></div></div></div>
 159 <div class="paragraph"><p>assuming you have the made the binding</p></div>
 160 <div class="listingblock">
 161 <div class="content"><div class="highlight"><pre><span class="k">structure</span><span class="w"> </span><span class="n">P</span><span class="w"> </span><span class="p">=</span><span class="w"> </span><span class="n">Printf</span><span class="w"></span>
 162 </pre></div></div></div>
 163 </div>
 164 </div>
 165 </div>
 166 <div class="sect1">
 167 <h2 id="_application_and_piping_operators">Application and piping operators</h2>
 168 <div class="sectionbody">
 169 <div class="paragraph"><p>The left and right application operators may also provide some notational
 170 convenience on their own. In general,</p></div>
 171 <div class="listingblock">
 172 <div class="content monospaced">
 173 <pre>f \&gt; x1 \&gt; ... \&gt; xN = f x1 ... xN</pre>
 174 </div></div>
 175 <div class="paragraph"><p>and</p></div>
 176 <div class="listingblock">
 177 <div class="content monospaced">
 178 <pre>xN &lt;/ ... &lt;/ x1 &lt;/ f = f x1 ... xN</pre>
 179 </div></div>
 180 <div class="paragraph"><p>If nothing else, both of them can eliminate parentheses. For example,</p></div>
 181 <div class="listingblock">
 182 <div class="content"><div class="highlight"><pre><span class="n">foo</span><span class="w"> </span><span class="p">(</span><span class="mi">1</span><span class="w"> </span><span class="n">+</span><span class="w"> </span><span class="mi">2</span><span class="p">)</span><span class="w"> </span><span class="p">=</span><span class="w"> </span><span class="n">foo</span><span class="w"> </span><span class="n">\&gt;</span><span class="w"> </span><span class="mi">1</span><span class="w"> </span><span class="n">+</span><span class="w"> </span><span class="mi">2</span><span class="w"></span>
 183 </pre></div></div></div>
 184 <div class="paragraph"><p>The left and right application operators are related to operators
 185 that could be described as the right and left piping operators:</p></div>
 186 <div class="listingblock">
 187 <div class="content"><div class="highlight"><pre><span class="k">infix</span><span class="w">  </span><span class="mi">1</span><span class="w"> </span><span class="n">&gt;|</span><span class="w">     </span><span class="k">val</span><span class="w"> </span><span class="k">op</span><span class="n">&gt;|</span><span class="w"> </span><span class="p">=</span><span class="w"> </span><span class="k">op</span><span class="n">&lt;/</span><span class="w">      </span><span class="cm">(* Left pipe *)</span><span class="w"></span>
 188 <span class="k">infixr</span><span class="w"> </span><span class="mi">1</span><span class="w"> </span><span class="n">|&lt;</span><span class="w">     </span><span class="k">val</span><span class="w"> </span><span class="k">op</span><span class="n">|&lt;</span><span class="w"> </span><span class="p">=</span><span class="w"> </span><span class="k">op</span><span class="n">\&gt;</span><span class="w">      </span><span class="cm">(* Right pipe *)</span><span class="w"></span>
 189 </pre></div></div></div>
 190 <div class="paragraph"><p>As you can see, the left and right piping operators, <span class="monospaced">&gt;|</span> and <span class="monospaced">|&lt;</span>,
 191 are the same as the right and left application operators,
 192 respectively, except the associativities are reversed and the binding
 193 strength is lower. They are useful for piping data through a sequence
 194 of operations. In general,</p></div>
 195 <div class="listingblock">
 196 <div class="content monospaced">
 197 <pre>x &gt;| f1 &gt;| ... &gt;| fN = fN (... (f1 x) ...) = (fN o ... o f1) x</pre>
 198 </div></div>
 199 <div class="paragraph"><p>and</p></div>
 200 <div class="listingblock">
 201 <div class="content monospaced">
 202 <pre>fN |&lt; ... |&lt; f1 |&lt; x = fN (... (f1 x) ...) = (fN o ... o f1) x</pre>
 203 </div></div>
 204 <div class="paragraph"><p>The right piping operator, <span class="monospaced">|&lt;</span>, is provided by the Haskell prelude as
 205 <span class="monospaced">$</span>. It can be convenient in CPS or continuation passing style.</p></div>
 206 <div class="paragraph"><p>A use for the left piping operator is with parsing combinators. In a
 207 strict language, like SML, eta-reduction is generally unsafe. Using
 208 the left piping operator, parsing functions can be formatted
 209 conveniently as</p></div>
 210 <div class="listingblock">
 211 <div class="content"><div class="highlight"><pre><span class="k">fun</span><span class="w"> </span><span class="n">parsingFunc</span><span class="w"> </span><span class="n">input</span><span class="w"> </span><span class="p">=</span><span class="w"></span>
 212 <span class="w">   </span><span class="n">input</span><span class="w"> </span><span class="n">&gt;|</span><span class="w"> </span><span class="cm">(* ... *)</span><span class="w"></span>
 213 <span class="w">         </span><span class="n">||</span><span class="w"> </span><span class="cm">(* ... *)</span><span class="w"></span>
 214 <span class="w">         </span><span class="n">||</span><span class="w"> </span><span class="cm">(* ... *)</span><span class="w"></span>
 215 </pre></div></div></div>
 216 <div class="paragraph"><p>where <span class="monospaced">||</span> is supposed to be a combinator provided by the parsing combinator
 217 library.</p></div>
 218 </div>
 219 </div>
 220 <div class="sect1">
 221 <h2 id="_about_precedences">About precedences</h2>
 222 <div class="sectionbody">
 223 <div class="paragraph"><p>You probably noticed that we redefined the
 224 <a href="OperatorPrecedence">precedences</a> of the function composition operator
 225 <span class="monospaced">o</span> and the assignment operator <span class="monospaced">:=</span>. Doing so is not strictly
 226 necessary, but can be convenient and should be relatively
 227 safe. Consider the following motivating examples from
 228 <a href="WesleyTerpstra"> Wesley W. Terpstra</a> relying on the redefined
 229 precedences:</p></div>
 230 <div class="listingblock">
 231 <div class="content"><div class="highlight"><pre><span class="n">Word8</span><span class="p">.</span><span class="n">fromInt</span><span class="w"> </span><span class="n">o</span><span class="w"> </span><span class="n">Char</span><span class="p">.</span><span class="n">ord</span><span class="w"> </span><span class="n">o</span><span class="w"> </span><span class="n">s</span><span class="w"> </span><span class="n">&lt;\String</span><span class="p">.</span><span class="n">sub</span><span class="w"></span>
 232 <span class="cm">(* Combining sectioning and composition *)</span><span class="w"></span>
 233
 234 <span class="n">x</span><span class="w"> </span><span class="n">:=</span><span class="w"> </span><span class="n">s</span><span class="w"> </span><span class="n">&lt;\String</span><span class="p">.</span><span class="n">sub\&gt;</span><span class="w"> </span><span class="n">i</span><span class="w"></span>
 235 <span class="cm">(* Assigning the result of an infixed application *)</span><span class="w"></span>
 236 </pre></div></div></div>
 237 <div class="paragraph"><p>In imperative languages, assignment usually has the lowest precedence
 238 (ignoring statement separators). The precedence of <span class="monospaced">:=</span> in the
 239 <a href="BasisLibrary"> Basis Library</a> is perhaps unnecessarily high, because
 240 an expression of the form <span class="monospaced">r := x</span> always returns a unit, which makes
 241 little sense to combine with anything. Dropping <span class="monospaced">:=</span> to the lowest
 242 precedence level makes it behave more like in other imperative
 243 languages.</p></div>
 244 <div class="paragraph"><p>The case for <span class="monospaced">o</span> is different. With the exception of <span class="monospaced">before</span> and
 245 <span class="monospaced">:=</span>, it doesn&#8217;t seem to make much sense to use <span class="monospaced">o</span> with any of the
 246 operators defined by the <a href="BasisLibrary"> Basis Library</a> in an
 247 unparenthesized expression. This is simply because none of the other
 248 operators deal with functions. It would seem that the precedence of
 249 <span class="monospaced">o</span> could be chosen completely arbitrarily from the set <span class="monospaced">{1, ..., 9}</span>
 250 without having any adverse effects with respect to other infix
 251 operators defined by the <a href="BasisLibrary"> Basis Library</a>.</p></div>
 252 </div>
 253 </div>
 254 <div class="sect1">
 255 <h2 id="_design_of_the_symbols">Design of the symbols</h2>
 256 <div class="sectionbody">
 257 <div class="paragraph"><p>The closest approximation of Haskell&#8217;s <span class="monospaced">x &grave;f&grave; y</span> syntax
 258 achievable in Standard ML would probably be something like
 259 <span class="monospaced">x &grave;f^ y</span>, but <span class="monospaced">^</span> is already used for string
 260 concatenation by the <a href="BasisLibrary"> Basis Library</a>. Other
 261 combinations of the characters <span class="monospaced">&grave;</span> and <span class="monospaced">^</span> would be
 262 possible, but none seems clearly the best visually. The symbols <span class="monospaced">&lt;\</span>,
 263 <span class="monospaced">\&gt;</span>, <span class="monospaced">&lt;/</span>, and <span class="monospaced">/&gt;</span> are reasonably concise and have a certain
 264 self-documenting appearance and symmetry, which can help to remember
 265 them.  As the names suggest, the symbols of the piping operators <span class="monospaced">&gt;|</span>
 266 and <span class="monospaced">|&lt;</span> are inspired by Unix shell pipelines.</p></div>
 267 </div>
 268 </div>
 269 <div class="sect1">
 270 <h2 id="_also_see">Also see</h2>
 271 <div class="sectionbody">
 272 <div class="ulist"><ul>
 273 <li>
 274 <p>
 275 <a href="Utilities">Utilities</a>
 276 </p>
 277 </li>
 278 </ul></div>
 279 </div>
 280 </div>
 281 </div>
 282 <div id="footnotes"><hr></div>
 283 <div id="footer">
 284 <div id="footer-text">
 285 </div>
 286 <div id="footer-badges">
 287 </div>
 288 </div>
 289 </body>
 290 </html>