aboutsummaryrefslogtreecommitdiff
path: root/src/regex/lib.rs.html
diff options
context:
space:
mode:
author2015-06-29 20:16:15 +0000
committer2015-06-29 20:16:15 +0000
commit64106c4d3d4ddba8c7bc2af75376e6d3d3d75601 (patch)
tree8c64d6e8be006486d975a651505fbbde61365cd6 /src/regex/lib.rs.html
downloadirsc-64106c4d3d4ddba8c7bc2af75376e6d3d3d75601.tar.gz
irsc-64106c4d3d4ddba8c7bc2af75376e6d3d3d75601.tar.xz
irsc-64106c4d3d4ddba8c7bc2af75376e6d3d3d75601.zip
Update documentationgh-pages
Diffstat (limited to 'src/regex/lib.rs.html')
-rw-r--r--src/regex/lib.rs.html959
1 files changed, 959 insertions, 0 deletions
diff --git a/src/regex/lib.rs.html b/src/regex/lib.rs.html
new file mode 100644
index 0000000..8331db1
--- /dev/null
+++ b/src/regex/lib.rs.html
@@ -0,0 +1,959 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+ <meta charset="utf-8">
+ <meta name="viewport" content="width=device-width, initial-scale=1.0">
+ <meta name="generator" content="rustdoc">
+ <meta name="description" content="Source to the Rust file `/home/travis/.cargo/registry/src/github.com-0a35038f75765ae4/regex-0.1.38/src/lib.rs`.">
+ <meta name="keywords" content="rust, rustlang, rust-lang">
+
+ <title>lib.rs.html -- source</title>
+
+ <link rel="stylesheet" type="text/css" href="../../main.css">
+
+ <link rel="shortcut icon" href="http://www.rust-lang.org/favicon.ico">
+
+</head>
+<body class="rustdoc">
+ <!--[if lte IE 8]>
+ <div class="warning">
+ This old browser is unsupported and will most likely display funky
+ things.
+ </div>
+ <![endif]-->
+
+
+
+ <section class="sidebar">
+ <a href='../../regex/index.html'><img src='http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png' alt='' width='100'></a>
+
+ </section>
+
+ <nav class="sub">
+ <form class="search-form js-only">
+ <div class="search-container">
+ <input class="search-input" name="search"
+ autocomplete="off"
+ placeholder="Click or press 'S' to search, '?' for more options..."
+ type="search">
+ </div>
+ </form>
+ </nav>
+
+ <section id='main' class="content source"><pre class="line-numbers"><span id="1"> 1</span>
+<span id="2"> 2</span>
+<span id="3"> 3</span>
+<span id="4"> 4</span>
+<span id="5"> 5</span>
+<span id="6"> 6</span>
+<span id="7"> 7</span>
+<span id="8"> 8</span>
+<span id="9"> 9</span>
+<span id="10"> 10</span>
+<span id="11"> 11</span>
+<span id="12"> 12</span>
+<span id="13"> 13</span>
+<span id="14"> 14</span>
+<span id="15"> 15</span>
+<span id="16"> 16</span>
+<span id="17"> 17</span>
+<span id="18"> 18</span>
+<span id="19"> 19</span>
+<span id="20"> 20</span>
+<span id="21"> 21</span>
+<span id="22"> 22</span>
+<span id="23"> 23</span>
+<span id="24"> 24</span>
+<span id="25"> 25</span>
+<span id="26"> 26</span>
+<span id="27"> 27</span>
+<span id="28"> 28</span>
+<span id="29"> 29</span>
+<span id="30"> 30</span>
+<span id="31"> 31</span>
+<span id="32"> 32</span>
+<span id="33"> 33</span>
+<span id="34"> 34</span>
+<span id="35"> 35</span>
+<span id="36"> 36</span>
+<span id="37"> 37</span>
+<span id="38"> 38</span>
+<span id="39"> 39</span>
+<span id="40"> 40</span>
+<span id="41"> 41</span>
+<span id="42"> 42</span>
+<span id="43"> 43</span>
+<span id="44"> 44</span>
+<span id="45"> 45</span>
+<span id="46"> 46</span>
+<span id="47"> 47</span>
+<span id="48"> 48</span>
+<span id="49"> 49</span>
+<span id="50"> 50</span>
+<span id="51"> 51</span>
+<span id="52"> 52</span>
+<span id="53"> 53</span>
+<span id="54"> 54</span>
+<span id="55"> 55</span>
+<span id="56"> 56</span>
+<span id="57"> 57</span>
+<span id="58"> 58</span>
+<span id="59"> 59</span>
+<span id="60"> 60</span>
+<span id="61"> 61</span>
+<span id="62"> 62</span>
+<span id="63"> 63</span>
+<span id="64"> 64</span>
+<span id="65"> 65</span>
+<span id="66"> 66</span>
+<span id="67"> 67</span>
+<span id="68"> 68</span>
+<span id="69"> 69</span>
+<span id="70"> 70</span>
+<span id="71"> 71</span>
+<span id="72"> 72</span>
+<span id="73"> 73</span>
+<span id="74"> 74</span>
+<span id="75"> 75</span>
+<span id="76"> 76</span>
+<span id="77"> 77</span>
+<span id="78"> 78</span>
+<span id="79"> 79</span>
+<span id="80"> 80</span>
+<span id="81"> 81</span>
+<span id="82"> 82</span>
+<span id="83"> 83</span>
+<span id="84"> 84</span>
+<span id="85"> 85</span>
+<span id="86"> 86</span>
+<span id="87"> 87</span>
+<span id="88"> 88</span>
+<span id="89"> 89</span>
+<span id="90"> 90</span>
+<span id="91"> 91</span>
+<span id="92"> 92</span>
+<span id="93"> 93</span>
+<span id="94"> 94</span>
+<span id="95"> 95</span>
+<span id="96"> 96</span>
+<span id="97"> 97</span>
+<span id="98"> 98</span>
+<span id="99"> 99</span>
+<span id="100">100</span>
+<span id="101">101</span>
+<span id="102">102</span>
+<span id="103">103</span>
+<span id="104">104</span>
+<span id="105">105</span>
+<span id="106">106</span>
+<span id="107">107</span>
+<span id="108">108</span>
+<span id="109">109</span>
+<span id="110">110</span>
+<span id="111">111</span>
+<span id="112">112</span>
+<span id="113">113</span>
+<span id="114">114</span>
+<span id="115">115</span>
+<span id="116">116</span>
+<span id="117">117</span>
+<span id="118">118</span>
+<span id="119">119</span>
+<span id="120">120</span>
+<span id="121">121</span>
+<span id="122">122</span>
+<span id="123">123</span>
+<span id="124">124</span>
+<span id="125">125</span>
+<span id="126">126</span>
+<span id="127">127</span>
+<span id="128">128</span>
+<span id="129">129</span>
+<span id="130">130</span>
+<span id="131">131</span>
+<span id="132">132</span>
+<span id="133">133</span>
+<span id="134">134</span>
+<span id="135">135</span>
+<span id="136">136</span>
+<span id="137">137</span>
+<span id="138">138</span>
+<span id="139">139</span>
+<span id="140">140</span>
+<span id="141">141</span>
+<span id="142">142</span>
+<span id="143">143</span>
+<span id="144">144</span>
+<span id="145">145</span>
+<span id="146">146</span>
+<span id="147">147</span>
+<span id="148">148</span>
+<span id="149">149</span>
+<span id="150">150</span>
+<span id="151">151</span>
+<span id="152">152</span>
+<span id="153">153</span>
+<span id="154">154</span>
+<span id="155">155</span>
+<span id="156">156</span>
+<span id="157">157</span>
+<span id="158">158</span>
+<span id="159">159</span>
+<span id="160">160</span>
+<span id="161">161</span>
+<span id="162">162</span>
+<span id="163">163</span>
+<span id="164">164</span>
+<span id="165">165</span>
+<span id="166">166</span>
+<span id="167">167</span>
+<span id="168">168</span>
+<span id="169">169</span>
+<span id="170">170</span>
+<span id="171">171</span>
+<span id="172">172</span>
+<span id="173">173</span>
+<span id="174">174</span>
+<span id="175">175</span>
+<span id="176">176</span>
+<span id="177">177</span>
+<span id="178">178</span>
+<span id="179">179</span>
+<span id="180">180</span>
+<span id="181">181</span>
+<span id="182">182</span>
+<span id="183">183</span>
+<span id="184">184</span>
+<span id="185">185</span>
+<span id="186">186</span>
+<span id="187">187</span>
+<span id="188">188</span>
+<span id="189">189</span>
+<span id="190">190</span>
+<span id="191">191</span>
+<span id="192">192</span>
+<span id="193">193</span>
+<span id="194">194</span>
+<span id="195">195</span>
+<span id="196">196</span>
+<span id="197">197</span>
+<span id="198">198</span>
+<span id="199">199</span>
+<span id="200">200</span>
+<span id="201">201</span>
+<span id="202">202</span>
+<span id="203">203</span>
+<span id="204">204</span>
+<span id="205">205</span>
+<span id="206">206</span>
+<span id="207">207</span>
+<span id="208">208</span>
+<span id="209">209</span>
+<span id="210">210</span>
+<span id="211">211</span>
+<span id="212">212</span>
+<span id="213">213</span>
+<span id="214">214</span>
+<span id="215">215</span>
+<span id="216">216</span>
+<span id="217">217</span>
+<span id="218">218</span>
+<span id="219">219</span>
+<span id="220">220</span>
+<span id="221">221</span>
+<span id="222">222</span>
+<span id="223">223</span>
+<span id="224">224</span>
+<span id="225">225</span>
+<span id="226">226</span>
+<span id="227">227</span>
+<span id="228">228</span>
+<span id="229">229</span>
+<span id="230">230</span>
+<span id="231">231</span>
+<span id="232">232</span>
+<span id="233">233</span>
+<span id="234">234</span>
+<span id="235">235</span>
+<span id="236">236</span>
+<span id="237">237</span>
+<span id="238">238</span>
+<span id="239">239</span>
+<span id="240">240</span>
+<span id="241">241</span>
+<span id="242">242</span>
+<span id="243">243</span>
+<span id="244">244</span>
+<span id="245">245</span>
+<span id="246">246</span>
+<span id="247">247</span>
+<span id="248">248</span>
+<span id="249">249</span>
+<span id="250">250</span>
+<span id="251">251</span>
+<span id="252">252</span>
+<span id="253">253</span>
+<span id="254">254</span>
+<span id="255">255</span>
+<span id="256">256</span>
+<span id="257">257</span>
+<span id="258">258</span>
+<span id="259">259</span>
+<span id="260">260</span>
+<span id="261">261</span>
+<span id="262">262</span>
+<span id="263">263</span>
+<span id="264">264</span>
+<span id="265">265</span>
+<span id="266">266</span>
+<span id="267">267</span>
+<span id="268">268</span>
+<span id="269">269</span>
+<span id="270">270</span>
+<span id="271">271</span>
+<span id="272">272</span>
+<span id="273">273</span>
+<span id="274">274</span>
+<span id="275">275</span>
+<span id="276">276</span>
+<span id="277">277</span>
+<span id="278">278</span>
+<span id="279">279</span>
+<span id="280">280</span>
+<span id="281">281</span>
+<span id="282">282</span>
+<span id="283">283</span>
+<span id="284">284</span>
+<span id="285">285</span>
+<span id="286">286</span>
+<span id="287">287</span>
+<span id="288">288</span>
+<span id="289">289</span>
+<span id="290">290</span>
+<span id="291">291</span>
+<span id="292">292</span>
+<span id="293">293</span>
+<span id="294">294</span>
+<span id="295">295</span>
+<span id="296">296</span>
+<span id="297">297</span>
+<span id="298">298</span>
+<span id="299">299</span>
+<span id="300">300</span>
+<span id="301">301</span>
+<span id="302">302</span>
+<span id="303">303</span>
+<span id="304">304</span>
+<span id="305">305</span>
+<span id="306">306</span>
+<span id="307">307</span>
+<span id="308">308</span>
+<span id="309">309</span>
+<span id="310">310</span>
+<span id="311">311</span>
+<span id="312">312</span>
+<span id="313">313</span>
+<span id="314">314</span>
+<span id="315">315</span>
+<span id="316">316</span>
+<span id="317">317</span>
+<span id="318">318</span>
+<span id="319">319</span>
+<span id="320">320</span>
+<span id="321">321</span>
+<span id="322">322</span>
+<span id="323">323</span>
+<span id="324">324</span>
+<span id="325">325</span>
+<span id="326">326</span>
+<span id="327">327</span>
+<span id="328">328</span>
+<span id="329">329</span>
+<span id="330">330</span>
+<span id="331">331</span>
+<span id="332">332</span>
+<span id="333">333</span>
+<span id="334">334</span>
+<span id="335">335</span>
+<span id="336">336</span>
+<span id="337">337</span>
+<span id="338">338</span>
+<span id="339">339</span>
+<span id="340">340</span>
+<span id="341">341</span>
+<span id="342">342</span>
+<span id="343">343</span>
+<span id="344">344</span>
+<span id="345">345</span>
+<span id="346">346</span>
+<span id="347">347</span>
+<span id="348">348</span>
+<span id="349">349</span>
+<span id="350">350</span>
+<span id="351">351</span>
+<span id="352">352</span>
+<span id="353">353</span>
+<span id="354">354</span>
+<span id="355">355</span>
+<span id="356">356</span>
+<span id="357">357</span>
+<span id="358">358</span>
+<span id="359">359</span>
+<span id="360">360</span>
+<span id="361">361</span>
+<span id="362">362</span>
+<span id="363">363</span>
+<span id="364">364</span>
+<span id="365">365</span>
+<span id="366">366</span>
+<span id="367">367</span>
+<span id="368">368</span>
+<span id="369">369</span>
+<span id="370">370</span>
+<span id="371">371</span>
+<span id="372">372</span>
+<span id="373">373</span>
+<span id="374">374</span>
+<span id="375">375</span>
+<span id="376">376</span>
+<span id="377">377</span>
+<span id="378">378</span>
+<span id="379">379</span>
+<span id="380">380</span>
+<span id="381">381</span>
+<span id="382">382</span>
+<span id="383">383</span>
+<span id="384">384</span>
+<span id="385">385</span>
+<span id="386">386</span>
+<span id="387">387</span>
+<span id="388">388</span>
+<span id="389">389</span>
+<span id="390">390</span>
+<span id="391">391</span>
+<span id="392">392</span>
+<span id="393">393</span>
+<span id="394">394</span>
+<span id="395">395</span>
+<span id="396">396</span>
+<span id="397">397</span>
+<span id="398">398</span>
+<span id="399">399</span>
+<span id="400">400</span>
+<span id="401">401</span>
+<span id="402">402</span>
+<span id="403">403</span>
+<span id="404">404</span>
+<span id="405">405</span>
+<span id="406">406</span>
+<span id="407">407</span>
+<span id="408">408</span>
+<span id="409">409</span>
+<span id="410">410</span>
+<span id="411">411</span>
+<span id="412">412</span>
+<span id="413">413</span>
+<span id="414">414</span>
+<span id="415">415</span>
+<span id="416">416</span>
+<span id="417">417</span>
+<span id="418">418</span>
+<span id="419">419</span>
+<span id="420">420</span>
+<span id="421">421</span>
+<span id="422">422</span>
+<span id="423">423</span>
+<span id="424">424</span>
+<span id="425">425</span>
+<span id="426">426</span>
+<span id="427">427</span>
+<span id="428">428</span>
+<span id="429">429</span>
+<span id="430">430</span>
+<span id="431">431</span>
+</pre><pre class='rust '>
+<span class='comment'>// Copyright 2014-2015 The Rust Project Developers. See the COPYRIGHT</span>
+<span class='comment'>// file at the top-level directory of this distribution and at</span>
+<span class='comment'>// http://rust-lang.org/COPYRIGHT.</span>
+<span class='comment'>//</span>
+<span class='comment'>// Licensed under the Apache License, Version 2.0 &lt;LICENSE-APACHE or</span>
+<span class='comment'>// http://www.apache.org/licenses/LICENSE-2.0&gt; or the MIT license</span>
+<span class='comment'>// &lt;LICENSE-MIT or http://opensource.org/licenses/MIT&gt;, at your</span>
+<span class='comment'>// option. This file may not be copied, modified, or distributed</span>
+<span class='comment'>// except according to those terms.</span>
+
+<span class='doccomment'>//! This crate provides a native implementation of regular expressions that is</span>
+<span class='doccomment'>//! heavily based on RE2 both in syntax and in implementation. Notably,</span>
+<span class='doccomment'>//! backreferences and arbitrary lookahead/lookbehind assertions are not</span>
+<span class='doccomment'>//! provided. In return, regular expression searching provided by this package</span>
+<span class='doccomment'>//! has excellent worst-case performance. The specific syntax supported is</span>
+<span class='doccomment'>//! documented further down.</span>
+<span class='doccomment'>//!</span>
+<span class='doccomment'>//! This crate&#39;s documentation provides some simple examples, describes Unicode</span>
+<span class='doccomment'>//! support and exhaustively lists the supported syntax. For more specific</span>
+<span class='doccomment'>//! details on the API, please see the documentation for the `Regex` type.</span>
+<span class='doccomment'>//!</span>
+<span class='doccomment'>//! # Usage</span>
+<span class='doccomment'>//!</span>
+<span class='doccomment'>//! This crate is [on crates.io](https://crates.io/crates/regex) and can be</span>
+<span class='doccomment'>//! used by adding `regex` to your dependencies in your project&#39;s `Cargo.toml`.</span>
+<span class='doccomment'>//!</span>
+<span class='doccomment'>//! ```toml</span>
+<span class='doccomment'>//! [dependencies]</span>
+<span class='doccomment'>//! regex = &quot;0.1.8&quot;</span>
+<span class='doccomment'>//! ```</span>
+<span class='doccomment'>//!</span>
+<span class='doccomment'>//! and this to your crate root:</span>
+<span class='doccomment'>//!</span>
+<span class='doccomment'>//! ```rust</span>
+<span class='doccomment'>//! extern crate regex;</span>
+<span class='doccomment'>//! ```</span>
+<span class='doccomment'>//!</span>
+<span class='doccomment'>//! # First example: find a date</span>
+<span class='doccomment'>//!</span>
+<span class='doccomment'>//! General use of regular expressions in this package involves compiling an</span>
+<span class='doccomment'>//! expression and then using it to search, split or replace text. For example,</span>
+<span class='doccomment'>//! to confirm that some text resembles a date:</span>
+<span class='doccomment'>//!</span>
+<span class='doccomment'>//! ```rust</span>
+<span class='doccomment'>//! use regex::Regex;</span>
+<span class='doccomment'>//! let re = Regex::new(r&quot;^\d{4}-\d{2}-\d{2}$&quot;).unwrap();</span>
+<span class='doccomment'>//! assert!(re.is_match(&quot;2014-01-01&quot;));</span>
+<span class='doccomment'>//! ```</span>
+<span class='doccomment'>//!</span>
+<span class='doccomment'>//! Notice the use of the `^` and `$` anchors. In this crate, every expression</span>
+<span class='doccomment'>//! is executed with an implicit `.*?` at the beginning and end, which allows</span>
+<span class='doccomment'>//! it to match anywhere in the text. Anchors can be used to ensure that the</span>
+<span class='doccomment'>//! full text matches an expression.</span>
+<span class='doccomment'>//!</span>
+<span class='doccomment'>//! This example also demonstrates the utility of</span>
+<span class='doccomment'>//! [raw strings](http://doc.rust-lang.org/stable/reference.html#raw-byte-string-literals)</span>
+<span class='doccomment'>//! in Rust, which</span>
+<span class='doccomment'>//! are just like regular strings except they are prefixed with an `r` and do</span>
+<span class='doccomment'>//! not process any escape sequences. For example, `&quot;\\d&quot;` is the same</span>
+<span class='doccomment'>//! expression as `r&quot;\d&quot;`.</span>
+<span class='doccomment'>//!</span>
+<span class='doccomment'>//! # The `regex!` macro</span>
+<span class='doccomment'>//!</span>
+<span class='doccomment'>//! Rust&#39;s compile-time meta-programming facilities provide a way to write a</span>
+<span class='doccomment'>//! `regex!` macro which compiles regular expressions *when your program</span>
+<span class='doccomment'>//! compiles*. Said differently, if you only use `regex!` to build regular</span>
+<span class='doccomment'>//! expressions in your program, then your program cannot compile with an</span>
+<span class='doccomment'>//! invalid regular expression. Moreover, the `regex!` macro compiles the</span>
+<span class='doccomment'>//! given expression to native Rust code, which ideally makes it faster.</span>
+<span class='doccomment'>//! Unfortunately (or fortunately), the dynamic implementation has had a lot</span>
+<span class='doccomment'>//! more optimization work put it into it currently, so it is faster than</span>
+<span class='doccomment'>//! the `regex!` macro in most cases.</span>
+<span class='doccomment'>//!</span>
+<span class='doccomment'>//! To use the `regex!` macro, you must enable the `plugin` feature and import</span>
+<span class='doccomment'>//! the `regex_macros` crate as a syntax extension:</span>
+<span class='doccomment'>//!</span>
+<span class='doccomment'>//! ```ignore</span>
+<span class='doccomment'>//! #![feature(plugin)]</span>
+<span class='doccomment'>//! #![plugin(regex_macros)]</span>
+<span class='doccomment'>//! extern crate regex;</span>
+<span class='doccomment'>//!</span>
+<span class='doccomment'>//! fn main() {</span>
+<span class='doccomment'>//! let re = regex!(r&quot;^\d{4}-\d{2}-\d{2}$&quot;);</span>
+<span class='doccomment'>//! assert!(re.is_match(&quot;2014-01-01&quot;));</span>
+<span class='doccomment'>//! }</span>
+<span class='doccomment'>//! ```</span>
+<span class='doccomment'>//!</span>
+<span class='doccomment'>//! There are a few things worth mentioning about using the `regex!` macro.</span>
+<span class='doccomment'>//! Firstly, the `regex!` macro *only* accepts string *literals*.</span>
+<span class='doccomment'>//! Secondly, the `regex` crate *must* be linked with the name `regex` since</span>
+<span class='doccomment'>//! the generated code depends on finding symbols in the `regex` crate.</span>
+<span class='doccomment'>//!</span>
+<span class='doccomment'>//! One downside of using the `regex!` macro is that it can increase the</span>
+<span class='doccomment'>//! size of your program&#39;s binary since it generates specialized Rust code.</span>
+<span class='doccomment'>//! The extra size probably won&#39;t be significant for a small number of</span>
+<span class='doccomment'>//! expressions, but 100+ calls to `regex!` will probably result in a</span>
+<span class='doccomment'>//! noticeably bigger binary.</span>
+<span class='doccomment'>//!</span>
+<span class='doccomment'>//! **NOTE**: This is implemented using a compiler plugin, which is not</span>
+<span class='doccomment'>//! available on the Rust 1.0 beta/stable channels. Therefore, you&#39;ll only</span>
+<span class='doccomment'>//! be able to use `regex!` on the nightlies.</span>
+<span class='doccomment'>//!</span>
+<span class='doccomment'>//! # Example: iterating over capture groups</span>
+<span class='doccomment'>//!</span>
+<span class='doccomment'>//! This crate provides convenient iterators for matching an expression</span>
+<span class='doccomment'>//! repeatedly against a search string to find successive non-overlapping</span>
+<span class='doccomment'>//! matches. For example, to find all dates in a string and be able to access</span>
+<span class='doccomment'>//! them by their component pieces:</span>
+<span class='doccomment'>//!</span>
+<span class='doccomment'>//! ```rust</span>
+<span class='doccomment'>//! # extern crate regex; use regex::Regex;</span>
+<span class='doccomment'>//! # fn main() {</span>
+<span class='doccomment'>//! let re = Regex::new(r&quot;(\d{4})-(\d{2})-(\d{2})&quot;).unwrap();</span>
+<span class='doccomment'>//! let text = &quot;2012-03-14, 2013-01-01 and 2014-07-05&quot;;</span>
+<span class='doccomment'>//! for cap in re.captures_iter(text) {</span>
+<span class='doccomment'>//! println!(&quot;Month: {} Day: {} Year: {}&quot;,</span>
+<span class='doccomment'>//! cap.at(2).unwrap_or(&quot;&quot;), cap.at(3).unwrap_or(&quot;&quot;),</span>
+<span class='doccomment'>//! cap.at(1).unwrap_or(&quot;&quot;));</span>
+<span class='doccomment'>//! }</span>
+<span class='doccomment'>//! // Output:</span>
+<span class='doccomment'>//! // Month: 03 Day: 14 Year: 2012</span>
+<span class='doccomment'>//! // Month: 01 Day: 01 Year: 2013</span>
+<span class='doccomment'>//! // Month: 07 Day: 05 Year: 2014</span>
+<span class='doccomment'>//! # }</span>
+<span class='doccomment'>//! ```</span>
+<span class='doccomment'>//!</span>
+<span class='doccomment'>//! Notice that the year is in the capture group indexed at `1`. This is</span>
+<span class='doccomment'>//! because the *entire match* is stored in the capture group at index `0`.</span>
+<span class='doccomment'>//!</span>
+<span class='doccomment'>//! # Example: replacement with named capture groups</span>
+<span class='doccomment'>//!</span>
+<span class='doccomment'>//! Building on the previous example, perhaps we&#39;d like to rearrange the date</span>
+<span class='doccomment'>//! formats. This can be done with text replacement. But to make the code</span>
+<span class='doccomment'>//! clearer, we can *name* our capture groups and use those names as variables</span>
+<span class='doccomment'>//! in our replacement text:</span>
+<span class='doccomment'>//!</span>
+<span class='doccomment'>//! ```rust</span>
+<span class='doccomment'>//! # extern crate regex; use regex::Regex;</span>
+<span class='doccomment'>//! # fn main() {</span>
+<span class='doccomment'>//! let re = Regex::new(r&quot;(?P&lt;y&gt;\d{4})-(?P&lt;m&gt;\d{2})-(?P&lt;d&gt;\d{2})&quot;).unwrap();</span>
+<span class='doccomment'>//! let before = &quot;2012-03-14, 2013-01-01 and 2014-07-05&quot;;</span>
+<span class='doccomment'>//! let after = re.replace_all(before, &quot;$m/$d/$y&quot;);</span>
+<span class='doccomment'>//! assert_eq!(after, &quot;03/14/2012, 01/01/2013 and 07/05/2014&quot;);</span>
+<span class='doccomment'>//! # }</span>
+<span class='doccomment'>//! ```</span>
+<span class='doccomment'>//!</span>
+<span class='doccomment'>//! The `replace` methods are actually polymorphic in the replacement, which</span>
+<span class='doccomment'>//! provides more flexibility than is seen here. (See the documentation for</span>
+<span class='doccomment'>//! `Regex::replace` for more details.)</span>
+<span class='doccomment'>//!</span>
+<span class='doccomment'>//! Note that if your regex gets complicated, you can use the `x` flag to</span>
+<span class='doccomment'>//! enable insigificant whitespace mode, which also lets you write comments:</span>
+<span class='doccomment'>//!</span>
+<span class='doccomment'>//! ```rust</span>
+<span class='doccomment'>//! # extern crate regex; use regex::Regex;</span>
+<span class='doccomment'>//! # fn main() {</span>
+<span class='doccomment'>//! let re = Regex::new(r&quot;(?x)</span>
+<span class='doccomment'>//! (?P&lt;y&gt;\d{4}) # the year</span>
+<span class='doccomment'>//! -</span>
+<span class='doccomment'>//! (?P&lt;m&gt;\d{2}) # the month</span>
+<span class='doccomment'>//! -</span>
+<span class='doccomment'>//! (?P&lt;d&gt;\d{2}) # the day</span>
+<span class='doccomment'>//! &quot;).unwrap();</span>
+<span class='doccomment'>//! let before = &quot;2012-03-14, 2013-01-01 and 2014-07-05&quot;;</span>
+<span class='doccomment'>//! let after = re.replace_all(before, &quot;$m/$d/$y&quot;);</span>
+<span class='doccomment'>//! assert_eq!(after, &quot;03/14/2012, 01/01/2013 and 07/05/2014&quot;);</span>
+<span class='doccomment'>//! # }</span>
+<span class='doccomment'>//! ```</span>
+<span class='doccomment'>//!</span>
+<span class='doccomment'>//! # Pay for what you use</span>
+<span class='doccomment'>//!</span>
+<span class='doccomment'>//! With respect to searching text with a regular expression, there are three</span>
+<span class='doccomment'>//! questions that can be asked:</span>
+<span class='doccomment'>//!</span>
+<span class='doccomment'>//! 1. Does the text match this expression?</span>
+<span class='doccomment'>//! 2. If so, where does it match?</span>
+<span class='doccomment'>//! 3. Where are the submatches?</span>
+<span class='doccomment'>//!</span>
+<span class='doccomment'>//! Generally speaking, this crate could provide a function to answer only #3,</span>
+<span class='doccomment'>//! which would subsume #1 and #2 automatically. However, it can be</span>
+<span class='doccomment'>//! significantly more expensive to compute the location of submatches, so it&#39;s</span>
+<span class='doccomment'>//! best not to do it if you don&#39;t need to.</span>
+<span class='doccomment'>//!</span>
+<span class='doccomment'>//! Therefore, only use what you need. For example, don&#39;t use `find` if you</span>
+<span class='doccomment'>//! only need to test if an expression matches a string. (Use `is_match`</span>
+<span class='doccomment'>//! instead.)</span>
+<span class='doccomment'>//!</span>
+<span class='doccomment'>//! # Unicode</span>
+<span class='doccomment'>//!</span>
+<span class='doccomment'>//! This implementation executes regular expressions **only** on sequences of</span>
+<span class='doccomment'>//! Unicode scalar values while exposing match locations as byte indices into</span>
+<span class='doccomment'>//! the search string.</span>
+<span class='doccomment'>//!</span>
+<span class='doccomment'>//! Currently, only simple case folding is supported. Namely, when matching</span>
+<span class='doccomment'>//! case-insensitively, the characters are first mapped using the</span>
+<span class='doccomment'>//! [simple case folding](ftp://ftp.unicode.org/Public/UNIDATA/CaseFolding.txt)</span>
+<span class='doccomment'>//! mapping.</span>
+<span class='doccomment'>//!</span>
+<span class='doccomment'>//! Regular expressions themselves are also **only** interpreted as a sequence</span>
+<span class='doccomment'>//! of Unicode scalar values. This means you can use Unicode characters</span>
+<span class='doccomment'>//! directly in your expression:</span>
+<span class='doccomment'>//!</span>
+<span class='doccomment'>//! ```rust</span>
+<span class='doccomment'>//! # extern crate regex; use regex::Regex;</span>
+<span class='doccomment'>//! # fn main() {</span>
+<span class='doccomment'>//! let re = Regex::new(r&quot;(?i)Δ+&quot;).unwrap();</span>
+<span class='doccomment'>//! assert_eq!(re.find(&quot;ΔδΔ&quot;), Some((0, 6)));</span>
+<span class='doccomment'>//! # }</span>
+<span class='doccomment'>//! ```</span>
+<span class='doccomment'>//!</span>
+<span class='doccomment'>//! Finally, Unicode general categories and scripts are available as character</span>
+<span class='doccomment'>//! classes. For example, you can match a sequence of numerals, Greek or</span>
+<span class='doccomment'>//! Cherokee letters:</span>
+<span class='doccomment'>//!</span>
+<span class='doccomment'>//! ```rust</span>
+<span class='doccomment'>//! # extern crate regex; use regex::Regex;</span>
+<span class='doccomment'>//! # fn main() {</span>
+<span class='doccomment'>//! let re = Regex::new(r&quot;[\pN\p{Greek}\p{Cherokee}]+&quot;).unwrap();</span>
+<span class='doccomment'>//! assert_eq!(re.find(&quot;abcΔᎠβⅠᏴγδⅡxyz&quot;), Some((3, 23)));</span>
+<span class='doccomment'>//! # }</span>
+<span class='doccomment'>//! ```</span>
+<span class='doccomment'>//!</span>
+<span class='doccomment'>//! # Syntax</span>
+<span class='doccomment'>//!</span>
+<span class='doccomment'>//! The syntax supported in this crate is almost in an exact correspondence</span>
+<span class='doccomment'>//! with the syntax supported by RE2. It is documented below.</span>
+<span class='doccomment'>//!</span>
+<span class='doccomment'>//! Note that the regular expression parser and abstract syntax are exposed in</span>
+<span class='doccomment'>//! a separate crate,</span>
+<span class='doccomment'>//! [`regex-syntax`](../regex_syntax/index.html).</span>
+<span class='doccomment'>//!</span>
+<span class='doccomment'>//! ## Matching one character</span>
+<span class='doccomment'>//!</span>
+<span class='doccomment'>//! &lt;pre class=&quot;rust&quot;&gt;</span>
+<span class='doccomment'>//! . any character except new line (includes new line with s flag)</span>
+<span class='doccomment'>//! [xyz] A character class matching either x, y or z.</span>
+<span class='doccomment'>//! [^xyz] A character class matching any character except x, y and z.</span>
+<span class='doccomment'>//! [a-z] A character class matching any character in range a-z.</span>
+<span class='doccomment'>//! \d digit (\p{Nd})</span>
+<span class='doccomment'>//! \D not digit</span>
+<span class='doccomment'>//! [:alpha:] ASCII character class ([A-Za-z])</span>
+<span class='doccomment'>//! [:^alpha:] Negated ASCII character class ([^A-Za-z])</span>
+<span class='doccomment'>//! \pN One-letter name Unicode character class</span>
+<span class='doccomment'>//! \p{Greek} Unicode character class (general category or script)</span>
+<span class='doccomment'>//! \PN Negated one-letter name Unicode character class</span>
+<span class='doccomment'>//! \P{Greek} negated Unicode character class (general category or script)</span>
+<span class='doccomment'>//! &lt;/pre&gt;</span>
+<span class='doccomment'>//!</span>
+<span class='doccomment'>//! Any named character class may appear inside a bracketed `[...]` character</span>
+<span class='doccomment'>//! class. For example, `[\p{Greek}\pN]` matches any Greek or numeral</span>
+<span class='doccomment'>//! character.</span>
+<span class='doccomment'>//!</span>
+<span class='doccomment'>//! ## Composites</span>
+<span class='doccomment'>//!</span>
+<span class='doccomment'>//! &lt;pre class=&quot;rust&quot;&gt;</span>
+<span class='doccomment'>//! xy concatenation (x followed by y)</span>
+<span class='doccomment'>//! x|y alternation (x or y, prefer x)</span>
+<span class='doccomment'>//! &lt;/pre&gt;</span>
+<span class='doccomment'>//!</span>
+<span class='doccomment'>//! ## Repetitions</span>
+<span class='doccomment'>//!</span>
+<span class='doccomment'>//! &lt;pre class=&quot;rust&quot;&gt;</span>
+<span class='doccomment'>//! x* zero or more of x (greedy)</span>
+<span class='doccomment'>//! x+ one or more of x (greedy)</span>
+<span class='doccomment'>//! x? zero or one of x (greedy)</span>
+<span class='doccomment'>//! x*? zero or more of x (ungreedy)</span>
+<span class='doccomment'>//! x+? one or more of x (ungreedy)</span>
+<span class='doccomment'>//! x?? zero or one of x (ungreedy)</span>
+<span class='doccomment'>//! x{n,m} at least n x and at most m x (greedy)</span>
+<span class='doccomment'>//! x{n,} at least n x (greedy)</span>
+<span class='doccomment'>//! x{n} exactly n x</span>
+<span class='doccomment'>//! x{n,m}? at least n x and at most m x (ungreedy)</span>
+<span class='doccomment'>//! x{n,}? at least n x (ungreedy)</span>
+<span class='doccomment'>//! x{n}? exactly n x</span>
+<span class='doccomment'>//! &lt;/pre&gt;</span>
+<span class='doccomment'>//!</span>
+<span class='doccomment'>//! ## Empty matches</span>
+<span class='doccomment'>//!</span>
+<span class='doccomment'>//! &lt;pre class=&quot;rust&quot;&gt;</span>
+<span class='doccomment'>//! ^ the beginning of text (or start-of-line with multi-line mode)</span>
+<span class='doccomment'>//! $ the end of text (or end-of-line with multi-line mode)</span>
+<span class='doccomment'>//! \A only the beginning of text (even with multi-line mode enabled)</span>
+<span class='doccomment'>//! \z only the end of text (even with multi-line mode enabled)</span>
+<span class='doccomment'>//! \b a Unicode word boundary (\w on one side and \W, \A, or \z on other)</span>
+<span class='doccomment'>//! \B not a Unicode word boundary</span>
+<span class='doccomment'>//! &lt;/pre&gt;</span>
+<span class='doccomment'>//!</span>
+<span class='doccomment'>//! ## Grouping and flags</span>
+<span class='doccomment'>//!</span>
+<span class='doccomment'>//! &lt;pre class=&quot;rust&quot;&gt;</span>
+<span class='doccomment'>//! (exp) numbered capture group (indexed by opening parenthesis)</span>
+<span class='doccomment'>//! (?P&amp;lt;name&amp;gt;exp) named (also numbered) capture group (allowed chars: [_0-9a-zA-Z])</span>
+<span class='doccomment'>//! (?:exp) non-capturing group</span>
+<span class='doccomment'>//! (?flags) set flags within current group</span>
+<span class='doccomment'>//! (?flags:exp) set flags for exp (non-capturing)</span>
+<span class='doccomment'>//! &lt;/pre&gt;</span>
+<span class='doccomment'>//!</span>
+<span class='doccomment'>//! Flags are each a single character. For example, `(?x)` sets the flag `x`</span>
+<span class='doccomment'>//! and `(?-x)` clears the flag `x`. Multiple flags can be set or cleared at</span>
+<span class='doccomment'>//! the same time: `(?xy)` sets both the `x` and `y` flags and `(?x-y)` sets</span>
+<span class='doccomment'>//! the `x` flag and clears the `y` flag.</span>
+<span class='doccomment'>//!</span>
+<span class='doccomment'>//! All flags are by default disabled. They are:</span>
+<span class='doccomment'>//!</span>
+<span class='doccomment'>//! &lt;pre class=&quot;rust&quot;&gt;</span>
+<span class='doccomment'>//! i case-insensitive</span>
+<span class='doccomment'>//! m multi-line mode: ^ and $ match begin/end of line</span>
+<span class='doccomment'>//! s allow . to match \n</span>
+<span class='doccomment'>//! U swap the meaning of x* and x*?</span>
+<span class='doccomment'>//! x ignore whitespace and allow line comments (starting with `#`)</span>
+<span class='doccomment'>//! &lt;/pre&gt;</span>
+<span class='doccomment'>//!</span>
+<span class='doccomment'>//! Here&#39;s an example that matches case-insensitively for only part of the</span>
+<span class='doccomment'>//! expression:</span>
+<span class='doccomment'>//!</span>
+<span class='doccomment'>//! ```rust</span>
+<span class='doccomment'>//! # extern crate regex; use regex::Regex;</span>
+<span class='doccomment'>//! # fn main() {</span>
+<span class='doccomment'>//! let re = Regex::new(r&quot;(?i)a+(?-i)b+&quot;).unwrap();</span>
+<span class='doccomment'>//! let cap = re.captures(&quot;AaAaAbbBBBb&quot;).unwrap();</span>
+<span class='doccomment'>//! assert_eq!(cap.at(0), Some(&quot;AaAaAbb&quot;));</span>
+<span class='doccomment'>//! # }</span>
+<span class='doccomment'>//! ```</span>
+<span class='doccomment'>//!</span>
+<span class='doccomment'>//! Notice that the `a+` matches either `a` or `A`, but the `b+` only matches</span>
+<span class='doccomment'>//! `b`.</span>
+<span class='doccomment'>//!</span>
+<span class='doccomment'>//! ## Escape sequences</span>
+<span class='doccomment'>//!</span>
+<span class='doccomment'>//! &lt;pre class=&quot;rust&quot;&gt;</span>
+<span class='doccomment'>//! \* literal *, works for any punctuation character: \.+*?()|[]{}^$</span>
+<span class='doccomment'>//! \a bell (\x07)</span>
+<span class='doccomment'>//! \f form feed (\x0C)</span>
+<span class='doccomment'>//! \t horizontal tab</span>
+<span class='doccomment'>//! \n new line</span>
+<span class='doccomment'>//! \r carriage return</span>
+<span class='doccomment'>//! \v vertical tab (\x0B)</span>
+<span class='doccomment'>//! \123 octal character code (up to three digits)</span>
+<span class='doccomment'>//! \x7F hex character code (exactly two digits)</span>
+<span class='doccomment'>//! \x{10FFFF} any hex character code corresponding to a Unicode code point</span>
+<span class='doccomment'>//! &lt;/pre&gt;</span>
+<span class='doccomment'>//!</span>
+<span class='doccomment'>//! ## Perl character classes (Unicode friendly)</span>
+<span class='doccomment'>//!</span>
+<span class='doccomment'>//! These classes are based on the definitions provided in</span>
+<span class='doccomment'>//! [UTS#18](http://www.unicode.org/reports/tr18/#Compatibility_Properties):</span>
+<span class='doccomment'>//!</span>
+<span class='doccomment'>//! &lt;pre class=&quot;rust&quot;&gt;</span>
+<span class='doccomment'>//! \d digit (\p{Nd})</span>
+<span class='doccomment'>//! \D not digit</span>
+<span class='doccomment'>//! \s whitespace (\p{White_Space})</span>
+<span class='doccomment'>//! \S not whitespace</span>
+<span class='doccomment'>//! \w word character (\p{Alphabetic} + \p{M} + \d + \p{Pc} + \p{Join_Control})</span>
+<span class='doccomment'>//! \W not word character</span>
+<span class='doccomment'>//! &lt;/pre&gt;</span>
+<span class='doccomment'>//!</span>
+<span class='doccomment'>//! ## ASCII character classes</span>
+<span class='doccomment'>//!</span>
+<span class='doccomment'>//! &lt;pre class=&quot;rust&quot;&gt;</span>
+<span class='doccomment'>//! [:alnum:] alphanumeric ([0-9A-Za-z])</span>
+<span class='doccomment'>//! [:alpha:] alphabetic ([A-Za-z])</span>
+<span class='doccomment'>//! [:ascii:] ASCII ([\x00-\x7F])</span>
+<span class='doccomment'>//! [:blank:] blank ([\t ])</span>
+<span class='doccomment'>//! [:cntrl:] control ([\x00-\x1F\x7F])</span>
+<span class='doccomment'>//! [:digit:] digits ([0-9])</span>
+<span class='doccomment'>//! [:graph:] graphical ([!-~])</span>
+<span class='doccomment'>//! [:lower:] lower case ([a-z])</span>
+<span class='doccomment'>//! [:print:] printable ([ -~])</span>
+<span class='doccomment'>//! [:punct:] punctuation ([!-/:-@[-`{-~])</span>
+<span class='doccomment'>//! [:space:] whitespace ([\t\n\v\f\r ])</span>
+<span class='doccomment'>//! [:upper:] upper case ([A-Z])</span>
+<span class='doccomment'>//! [:word:] word characters ([0-9A-Za-z_])</span>
+<span class='doccomment'>//! [:xdigit:] hex digit ([0-9A-Fa-f])</span>
+<span class='doccomment'>//! &lt;/pre&gt;</span>
+<span class='doccomment'>//!</span>
+<span class='doccomment'>//! # Untrusted input</span>
+<span class='doccomment'>//!</span>
+<span class='doccomment'>//! This crate can handle both untrusted regular expressions and untrusted</span>
+<span class='doccomment'>//! search text.</span>
+<span class='doccomment'>//!</span>
+<span class='doccomment'>//! Untrusted regular expressions are handled by capping the size of a compiled</span>
+<span class='doccomment'>//! regular expression. (See `Regex::with_size_limit`.) Without this, it would</span>
+<span class='doccomment'>//! be trivial for an attacker to exhaust your system&#39;s memory with expressions</span>
+<span class='doccomment'>//! like `a{100}{100}{100}`.</span>
+<span class='doccomment'>//!</span>
+<span class='doccomment'>//! Untrusted search text is allowed because the matching engine(s) in this</span>
+<span class='doccomment'>//! crate have time complexity `O(mn)` (with `m ~ regex` and `n ~ search</span>
+<span class='doccomment'>//! text`), which means there&#39;s no way to cause exponential blow-up like with</span>
+<span class='doccomment'>//! some other regular expression engines. (We pay for this by disallowing</span>
+<span class='doccomment'>//! features like arbitrary look-ahead and back-references.)</span>
+
+<span class='attribute'>#<span class='op'>!</span>[<span class='ident'>deny</span>(<span class='ident'>missing_docs</span>)]</span>
+<span class='attribute'>#<span class='op'>!</span>[<span class='ident'>cfg_attr</span>(<span class='ident'>test</span>, <span class='ident'>deny</span>(<span class='ident'>warnings</span>))]</span>
+<span class='attribute'>#<span class='op'>!</span>[<span class='ident'>cfg_attr</span>(<span class='ident'>feature</span> <span class='op'>=</span> <span class='string'>&quot;pattern&quot;</span>, <span class='ident'>feature</span>(<span class='ident'>pattern</span>))]</span>
+<span class='attribute'>#<span class='op'>!</span>[<span class='ident'>doc</span>(<span class='ident'>html_logo_url</span> <span class='op'>=</span> <span class='string'>&quot;http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png&quot;</span>,
+ <span class='ident'>html_favicon_url</span> <span class='op'>=</span> <span class='string'>&quot;http://www.rust-lang.org/favicon.ico&quot;</span>,
+ <span class='ident'>html_root_url</span> <span class='op'>=</span> <span class='string'>&quot;http://doc.rust-lang.org/regex/&quot;</span>)]</span>
+
+<span class='kw'>extern</span> <span class='kw'>crate</span> <span class='ident'>aho_corasick</span>;
+<span class='kw'>extern</span> <span class='kw'>crate</span> <span class='ident'>memchr</span>;
+<span class='kw'>extern</span> <span class='kw'>crate</span> <span class='ident'>regex_syntax</span> <span class='kw'>as</span> <span class='ident'>syntax</span>;
+
+<span class='kw'>pub</span> <span class='kw'>use</span> <span class='ident'>re</span>::{
+ <span class='ident'>Regex</span>, <span class='ident'>Error</span>, <span class='ident'>Captures</span>, <span class='ident'>SubCaptures</span>, <span class='ident'>SubCapturesPos</span>, <span class='ident'>SubCapturesNamed</span>,
+ <span class='ident'>FindCaptures</span>, <span class='ident'>FindMatches</span>,
+ <span class='ident'>Replacer</span>, <span class='ident'>NoExpand</span>, <span class='ident'>RegexSplits</span>, <span class='ident'>RegexSplitsN</span>,
+ <span class='ident'>quote</span>, <span class='ident'>is_match</span>,
+};
+
+<span class='kw'>mod</span> <span class='ident'>backtrack</span>;
+<span class='kw'>mod</span> <span class='ident'>char</span>;
+<span class='kw'>mod</span> <span class='ident'>compile</span>;
+<span class='kw'>mod</span> <span class='ident'>input</span>;
+<span class='kw'>mod</span> <span class='ident'>pool</span>;
+<span class='kw'>mod</span> <span class='ident'>prefix</span>;
+<span class='kw'>mod</span> <span class='ident'>program</span>;
+<span class='kw'>mod</span> <span class='ident'>nfa</span>;
+<span class='kw'>mod</span> <span class='ident'>re</span>;
+
+<span class='doccomment'>/// The `internal` module exists to support the `regex!` macro and other</span>
+<span class='doccomment'>/// suspicious activity, such as testing different matching engines.</span>
+<span class='attribute'>#[<span class='ident'>doc</span>(<span class='ident'>hidden</span>)]</span>
+<span class='kw'>pub</span> <span class='kw'>mod</span> <span class='ident'>internal</span> {
+ <span class='kw'>pub</span> <span class='kw'>use</span> <span class='ident'>char</span>::<span class='ident'>Char</span>;
+ <span class='kw'>pub</span> <span class='kw'>use</span> <span class='ident'>input</span>::{<span class='ident'>Input</span>, <span class='ident'>CharInput</span>, <span class='ident'>InputAt</span>};
+ <span class='kw'>pub</span> <span class='kw'>use</span> <span class='ident'>program</span>::{
+ <span class='ident'>Program</span>, <span class='ident'>MatchEngine</span>, <span class='ident'>CharRanges</span>, <span class='ident'>Inst</span>, <span class='ident'>LookInst</span>, <span class='ident'>OneChar</span>,
+ };
+ <span class='kw'>pub</span> <span class='kw'>use</span> <span class='ident'>re</span>::<span class='ident'>ExNative</span>;
+ <span class='kw'>pub</span> <span class='kw'>use</span> <span class='ident'>re</span>::<span class='ident'>Regex</span>::{<span class='ident'>Dynamic</span>, <span class='ident'>Native</span>};
+}
+</pre>
+</section>
+ <section id='search' class="content hidden"></section>
+
+ <section class="footer"></section>
+
+ <div id="help" class="hidden">
+ <div class="shortcuts">
+ <h1>Keyboard shortcuts</h1>
+ <dl>
+ <dt>?</dt>
+ <dd>Show this help dialog</dd>
+ <dt>S</dt>
+ <dd>Focus the search field</dd>
+ <dt>&larrb;</dt>
+ <dd>Move up in search results</dd>
+ <dt>&rarrb;</dt>
+ <dd>Move down in search results</dd>
+ <dt>&#9166;</dt>
+ <dd>Go to active search result</dd>
+ </dl>
+ </div>
+ <div class="infos">
+ <h1>Search tricks</h1>
+ <p>
+ Prefix searches with a type followed by a colon (e.g.
+ <code>fn:</code>) to restrict the search to a given type.
+ </p>
+ <p>
+ Accepted types are: <code>fn</code>, <code>mod</code>,
+ <code>struct</code>, <code>enum</code>,
+ <code>trait</code>, <code>typedef</code> (or
+ <code>tdef</code>).
+ </p>
+ <p>
+ Search functions by type signature (e.g.
+ <code>vec -> usize</code>)
+ </p>
+ </div>
+ </div>
+
+
+
+ <script>
+ window.rootPath = "../../";
+ window.currentCrate = "regex";
+ window.playgroundUrl = "";
+ </script>
+ <script src="../../jquery.js"></script>
+ <script src="../../main.js"></script>
+
+ <script async src="../../search-index.js"></script>
+</body>
+</html> \ No newline at end of file