Inicio Explorar Ayuda
Iniciar sesión
RONCC
/
HPC-Tools-for-Quantum-Computing
Seguir 1
Destacar 0
Fork 0
Archivos Incidencias 0 Pull Requests 0 Wiki
Árbol: 441f89c8c5
Ramas Etiquetas
HPC-Tools-fo...
/
docs
/
doc
/
synstructure
/
struct.Structure.html

struct.Structure.html 54 KB
Histórico Raw

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468 
  1. <!DOCTYPE html>
    2. 

  2. <html lang="en">
    3. 

  3. <head>
    4. 

  4.     <meta charset="utf-8">
    5. 

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

  6.     <meta name="generator" content="rustdoc">
    7. 

  7.     <meta name="description" content="API documentation for the Rust `Structure` struct in crate `synstructure`.">
    8. 

  8.     <meta name="keywords" content="rust, rustlang, rust-lang, Structure">
    9. 

  9. 

  10.     <title>synstructure::Structure - Rust</title>
    11. 

  11. 

  12.     <link rel="stylesheet" type="text/css" href="../normalize.css">
    13. 

  13.     <link rel="stylesheet" type="text/css" href="../rustdoc.css" id="mainThemeStyle">
    14. 

  14.     
    15. 

  15.     <link rel="stylesheet" type="text/css" href="../dark.css">
    16. 

  16.     <link rel="stylesheet" type="text/css" href="../main.css" id="themeStyle">
    17. 

  17.     <script src="../storage.js"></script>
    18. 

  18.     
    19. 

  19. 

  20.     
    21. 

  21.     
    22. 

  22. </head>
    23. 

  23. <body class="rustdoc struct">
    24. 

  24.     <!--[if lte IE 8]>
    25. 

  25.     <div class="warning">
    26. 

  26.         This old browser is unsupported and will most likely display funky
    27. 

  27.         things.
    28. 

  28.     </div>
    29. 

  29.     <![endif]-->
    30. 

  30. 

  31.     
    32. 

  32. 

  33.     <nav class="sidebar">
    34. 

  34.         <div class="sidebar-menu">&#9776;</div>
    35. 

  35.         
    36. 

  36.         <p class='location'>Struct Structure</p><div class="sidebar-elems"><div class="block items"><a class="sidebar-title" href="#methods">Methods</a><div class="sidebar-links"><a href="#method.new">new</a><a href="#method.variants">variants</a><a href="#method.variants_mut">variants_mut</a><a href="#method.ast">ast</a><a href="#method.omitted_variants">omitted_variants</a><a href="#method.each">each</a><a href="#method.fold">fold</a><a href="#method.each_variant">each_variant</a><a href="#method.filter">filter</a><a href="#method.filter_variants">filter_variants</a><a href="#method.remove_variant">remove_variant</a><a href="#method.bind_with">bind_with</a><a href="#method.binding_name">binding_name</a><a href="#method.referenced_ty_params">referenced_ty_params</a><a href="#method.add_trait_bounds">add_trait_bounds</a><a href="#method.bound_impl">bound_impl</a><a href="#method.unsafe_bound_impl">unsafe_bound_impl</a><a href="#method.unbound_impl">unbound_impl</a><a href="#method.unsafe_unbound_impl">unsafe_unbound_impl</a></div><a class="sidebar-title" href="#implementations">Trait Implementations</a><div class="sidebar-links"><a href="#impl-Debug">Debug</a><a href="#impl-Clone">Clone</a><a href="#impl-PartialEq">PartialEq</a><a href="#impl-Eq">Eq</a><a href="#impl-Hash">Hash</a></div></div><p class='location'><a href='index.html'>synstructure</a></p><script>window.sidebarCurrent = {name: 'Structure', ty: 'struct', relpath: ''};</script><script defer src="sidebar-items.js"></script></div>
    37. 

  37.     </nav>
    38. 

  38. 

  39.     <div class="theme-picker">
    40. 

  40.         <button id="theme-picker" aria-label="Pick another theme!">
    41. 

  41.             <img src="../brush.svg" width="18" alt="Pick another theme!">
    42. 

  42.         </button>
    43. 

  43.         <div id="theme-choices"></div>
    44. 

  44.     </div>
    45. 

  45.     <script src="../theme.js"></script>
    46. 

  46.     <nav class="sub">
    47. 

  47.         <form class="search-form js-only">
    48. 

  48.             <div class="search-container">
    49. 

  49.                 <input class="search-input" name="search"
    50. 

  50.                        autocomplete="off"
    51. 

  51.                        placeholder="Click or press ‘S’ to search, ‘?’ for more options…"
    52. 

  52.                        type="search">
    53. 

  53.             </div>
    54. 

  54.         </form>
    55. 

  55.     </nav>
    56. 

  56. 

  57.     <section id='main' class="content">
    58. 

  58. <h1 class='fqn'><span class='in-band'>Struct <a href='index.html'>synstructure</a>::<wbr><a class="struct" href=''>Structure</a></span><span class='out-of-band'><span id='render-detail'>
    59. 

  59.                    <a id="toggle-all-docs" href="javascript:void(0)" title="collapse all docs">
    60. 

  60.                        [<span class='inner'>&#x2212;</span>]
    61. 

  61.                    </a>
    62. 

  62.                </span><a class='srclink' href='../src/synstructure/lib.rs.html#859-863' title='goto source code'>[src]</a></span></h1>
    63. 

  63. <pre class='rust struct'>pub struct Structure&lt;'a&gt; { /* fields omitted */ }</pre><div class='docblock'><p>A wrapper around a <code>syn</code> <code>DeriveInput</code> which provides utilities for creating
    64. 

  64. custom derive trait implementations.</p>
    65. 

  65. </div>
    66. 

  66.                     <h2 id='methods' class='small-section-header'>
    67. 

  67.                       Methods<a href='#methods' class='anchor'></a>
    68. 

  68.                     </h2>
    69. 

  69.                 <h3 id='impl' class='impl'><span class='in-band'><code>impl&lt;'a&gt; <a class="struct" href="../synstructure/struct.Structure.html" title="struct synstructure::Structure">Structure</a>&lt;'a&gt;</code><a href='#impl' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/synstructure/lib.rs.html#865-1469' title='goto source code'>[src]</a></span></h3>
    70. 

  70. <div class='impl-items'><h4 id='method.new' class="method"><span id='new.v' class='invisible'><code>pub fn <a href='#method.new' class='fnname'>new</a>(ast: &amp;'a <a class="struct" href="../syn/derive/struct.DeriveInput.html" title="struct syn::derive::DeriveInput">DeriveInput</a>) -&gt; Self</code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/synstructure/lib.rs.html#868-907' title='goto source code'>[src]</a></span></h4>
    71. 

  71. <div class='docblock'><p>Create a new <code>Structure</code> with the variants and fields from the passed-in
    72. 

  72. <code>DeriveInput</code>.</p>
    73. 

  73. </div><h4 id='method.variants' class="method"><span id='variants.v' class='invisible'><code>pub fn <a href='#method.variants' class='fnname'>variants</a>(&amp;self) -&gt; <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">&amp;[</a><a class="struct" href="../synstructure/struct.VariantInfo.html" title="struct synstructure::VariantInfo">VariantInfo</a>&lt;'a&gt;<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">]</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/synstructure/lib.rs.html#910-912' title='goto source code'>[src]</a></span></h4>
    74. 

  74. <div class='docblock'><p>Returns a slice of the variants in this Structure.</p>
    75. 

  75. </div><h4 id='method.variants_mut' class="method"><span id='variants_mut.v' class='invisible'><code>pub fn <a href='#method.variants_mut' class='fnname'>variants_mut</a>(&amp;mut self) -&gt; <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">&amp;mut [</a><a class="struct" href="../synstructure/struct.VariantInfo.html" title="struct synstructure::VariantInfo">VariantInfo</a>&lt;'a&gt;<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">]</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/synstructure/lib.rs.html#915-917' title='goto source code'>[src]</a></span></h4>
    76. 

  76. <div class='docblock'><p>Returns a mut slice of the variants in this Structure.</p>
    77. 

  77. </div><h4 id='method.ast' class="method"><span id='ast.v' class='invisible'><code>pub fn <a href='#method.ast' class='fnname'>ast</a>(&amp;self) -&gt; &amp;'a <a class="struct" href="../syn/derive/struct.DeriveInput.html" title="struct syn::derive::DeriveInput">DeriveInput</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/synstructure/lib.rs.html#921-923' title='goto source code'>[src]</a></span></h4>
    78. 

  78. <div class='docblock'><p>Returns a reference to the underlying <code>syn</code> AST node which this
    79. 

  79. <code>Structure</code> was created from.</p>
    80. 

  80. </div><h4 id='method.omitted_variants' class="method"><span id='omitted_variants.v' class='invisible'><code>pub fn <a href='#method.omitted_variants' class='fnname'>omitted_variants</a>(&amp;self) -&gt; <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/synstructure/lib.rs.html#926-928' title='goto source code'>[src]</a></span></h4>
    81. 

  81. <div class='docblock'><p>True if any variants were omitted due to a <code>filter_variants</code> call.</p>
    82. 

  82. </div><h4 id='method.each' class="method"><span id='each.v' class='invisible'><code>pub fn <a href='#method.each' class='fnname'>each</a>&lt;F, R&gt;(&amp;self, f: F) -&gt; <a class="struct" href="../quote/tokens/struct.Tokens.html" title="struct quote::tokens::Tokens">Tokens</a> <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;F: <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/function/trait.FnMut.html" title="trait core::ops::function::FnMut">FnMut</a>(&amp;<a class="struct" href="../synstructure/struct.BindingInfo.html" title="struct synstructure::BindingInfo">BindingInfo</a>) -&gt; R,<br>&nbsp;&nbsp;&nbsp;&nbsp;R: <a class="trait" href="../quote/to_tokens/trait.ToTokens.html" title="trait quote::to_tokens::ToTokens">ToTokens</a>,&nbsp;</span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/synstructure/lib.rs.html#966-979' title='goto source code'>[src]</a></span></h4>
    83. 

  83. <div class='docblock'><p>Runs the passed-in function once for each bound field, passing in a <code>BindingInfo</code>.
    84. 

  84. and generating <code>match</code> arms which evaluate the returned tokens.</p>
    85. 

  85. <p>This method will ignore variants or fields which are ignored through the
    86. 

  86. <code>filter</code> and <code>filter_variant</code> methods.</p>
    87. 

  87. <h1 id="example" class="section-header"><a href="#example">Example</a></h1>
    88. 

  88. <pre class="rust rust-example-rendered">
    89. 

  89. <span class="kw">let</span> <span class="ident">di</span> <span class="op">=</span> <span class="ident">syn</span>::<span class="ident">parse_derive_input</span>(<span class="string">r#&quot;
    90. 

  90.     enum A {
    91. 

  91.         B(i32, i32),
    92. 

  92.         C(u32),
    93. 

  93.     }
    94. 

  94. &quot;#</span>).<span class="ident">unwrap</span>();
    95. 

  95. <span class="kw">let</span> <span class="ident">s</span> <span class="op">=</span> <span class="ident">Structure</span>::<span class="ident">new</span>(<span class="kw-2">&amp;</span><span class="ident">di</span>);
    96. 

  96. 

  97. <span class="macro">assert_eq</span><span class="macro">!</span>(
    98. 

  98.     <span class="ident">s</span>.<span class="ident">each</span>(<span class="op">|</span><span class="ident">bi</span><span class="op">|</span> <span class="macro">quote</span><span class="macro">!</span>(<span class="macro">println</span><span class="macro">!</span>(<span class="string">&quot;{:?}&quot;</span>, #<span class="ident">bi</span>))),
    99. 

  99. 

  100.     <span class="macro">quote</span><span class="macro">!</span>{
    101. 

  101.         <span class="ident">A</span>::<span class="ident">B</span>(<span class="kw-2">ref</span> <span class="ident">__binding_0</span>, <span class="kw-2">ref</span> <span class="ident">__binding_1</span>,) <span class="op">=&gt;</span> {
    102. 

  102.             { <span class="macro">println</span><span class="macro">!</span>(<span class="string">&quot;{:?}&quot;</span>, <span class="ident">__binding_0</span>) }
    103. 

  103.             { <span class="macro">println</span><span class="macro">!</span>(<span class="string">&quot;{:?}&quot;</span>, <span class="ident">__binding_1</span>) }
    104. 

  104.         }
    105. 

  105.         <span class="ident">A</span>::<span class="ident">C</span>(<span class="kw-2">ref</span> <span class="ident">__binding_0</span>,) <span class="op">=&gt;</span> {
    106. 

  106.             { <span class="macro">println</span><span class="macro">!</span>(<span class="string">&quot;{:?}&quot;</span>, <span class="ident">__binding_0</span>) }
    107. 

  107.         }
    108. 

  108.     }
    109. 

  109. );</pre>
    110. 

  110. </div><h4 id='method.fold' class="method"><span id='fold.v' class='invisible'><code>pub fn <a href='#method.fold' class='fnname'>fold</a>&lt;F, I, R&gt;(&amp;self, init: I, f: F) -&gt; <a class="struct" href="../quote/tokens/struct.Tokens.html" title="struct quote::tokens::Tokens">Tokens</a> <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;F: <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/function/trait.FnMut.html" title="trait core::ops::function::FnMut">FnMut</a>(<a class="struct" href="../quote/tokens/struct.Tokens.html" title="struct quote::tokens::Tokens">Tokens</a>, &amp;<a class="struct" href="../synstructure/struct.BindingInfo.html" title="struct synstructure::BindingInfo">BindingInfo</a>) -&gt; R,<br>&nbsp;&nbsp;&nbsp;&nbsp;I: <a class="trait" href="../quote/to_tokens/trait.ToTokens.html" title="trait quote::to_tokens::ToTokens">ToTokens</a>,<br>&nbsp;&nbsp;&nbsp;&nbsp;R: <a class="trait" href="../quote/to_tokens/trait.ToTokens.html" title="trait quote::to_tokens::ToTokens">ToTokens</a>,&nbsp;</span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/synstructure/lib.rs.html#1019-1033' title='goto source code'>[src]</a></span></h4>
    111. 

  111. <div class='docblock'><p>Runs the passed-in function once for each bound field, passing in the
    112. 

  112. result of the previous call, and a <code>BindingInfo</code>. generating <code>match</code>
    113. 

  113. arms which evaluate to the resulting tokens.</p>
    114. 

  114. <p>This method will ignore variants or fields which are ignored through the
    115. 

  115. <code>filter</code> and <code>filter_variant</code> methods.</p>
    116. 

  116. <p>If a variant has been ignored, it will return the <code>init</code> value.</p>
    117. 

  117. <h1 id="example-1" class="section-header"><a href="#example-1">Example</a></h1>
    118. 

  118. <pre class="rust rust-example-rendered">
    119. 

  119. <span class="kw">let</span> <span class="ident">di</span> <span class="op">=</span> <span class="ident">syn</span>::<span class="ident">parse_derive_input</span>(<span class="string">r#&quot;
    120. 

  120.     enum A {
    121. 

  121.         B(i32, i32),
    122. 

  122.         C(u32),
    123. 

  123.     }
    124. 

  124. &quot;#</span>).<span class="ident">unwrap</span>();
    125. 

  125. <span class="kw">let</span> <span class="ident">s</span> <span class="op">=</span> <span class="ident">Structure</span>::<span class="ident">new</span>(<span class="kw-2">&amp;</span><span class="ident">di</span>);
    126. 

  126. 

  127. <span class="macro">assert_eq</span><span class="macro">!</span>(
    128. 

  128.     <span class="ident">s</span>.<span class="ident">fold</span>(<span class="macro">quote</span><span class="macro">!</span>(<span class="number">0</span>), <span class="op">|</span><span class="ident">acc</span>, <span class="ident">bi</span><span class="op">|</span> <span class="macro">quote</span><span class="macro">!</span>(#<span class="ident">acc</span> <span class="op">+</span> #<span class="ident">bi</span>)),
    129. 

  129. 

  130.     <span class="macro">quote</span><span class="macro">!</span>{
    131. 

  131.         <span class="ident">A</span>::<span class="ident">B</span>(<span class="kw-2">ref</span> <span class="ident">__binding_0</span>, <span class="kw-2">ref</span> <span class="ident">__binding_1</span>,) <span class="op">=&gt;</span> {
    132. 

  132.             <span class="number">0</span> <span class="op">+</span> <span class="ident">__binding_0</span> <span class="op">+</span> <span class="ident">__binding_1</span>
    133. 

  133.         }
    134. 

  134.         <span class="ident">A</span>::<span class="ident">C</span>(<span class="kw-2">ref</span> <span class="ident">__binding_0</span>,) <span class="op">=&gt;</span> {
    135. 

  135.             <span class="number">0</span> <span class="op">+</span> <span class="ident">__binding_0</span>
    136. 

  136.         }
    137. 

  137.     }
    138. 

  138. );</pre>
    139. 

  139. </div><h4 id='method.each_variant' class="method"><span id='each_variant.v' class='invisible'><code>pub fn <a href='#method.each_variant' class='fnname'>each_variant</a>&lt;F, R&gt;(&amp;self, f: F) -&gt; <a class="struct" href="../quote/tokens/struct.Tokens.html" title="struct quote::tokens::Tokens">Tokens</a> <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;F: <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/function/trait.FnMut.html" title="trait core::ops::function::FnMut">FnMut</a>(&amp;<a class="struct" href="../synstructure/struct.VariantInfo.html" title="struct synstructure::VariantInfo">VariantInfo</a>) -&gt; R,<br>&nbsp;&nbsp;&nbsp;&nbsp;R: <a class="trait" href="../quote/to_tokens/trait.ToTokens.html" title="trait quote::to_tokens::ToTokens">ToTokens</a>,&nbsp;</span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/synstructure/lib.rs.html#1074-1089' title='goto source code'>[src]</a></span></h4>
    140. 

  140. <div class='docblock'><p>Runs the passed-in function once for each variant, passing in a
    141. 

  141. <code>VariantInfo</code>. and generating <code>match</code> arms which evaluate the returned
    142. 

  142. tokens.</p>
    143. 

  143. <p>This method will ignore variants and not bind fields which are ignored
    144. 

  144. through the <code>filter</code> and <code>filter_variant</code> methods.</p>
    145. 

  145. <h1 id="example-2" class="section-header"><a href="#example-2">Example</a></h1>
    146. 

  146. <pre class="rust rust-example-rendered">
    147. 

  147. <span class="kw">let</span> <span class="ident">di</span> <span class="op">=</span> <span class="ident">syn</span>::<span class="ident">parse_derive_input</span>(<span class="string">r#&quot;
    148. 

  148.     enum A {
    149. 

  149.         B(i32, i32),
    150. 

  150.         C(u32),
    151. 

  151.     }
    152. 

  152. &quot;#</span>).<span class="ident">unwrap</span>();
    153. 

  153. <span class="kw">let</span> <span class="ident">s</span> <span class="op">=</span> <span class="ident">Structure</span>::<span class="ident">new</span>(<span class="kw-2">&amp;</span><span class="ident">di</span>);
    154. 

  154. 

  155. <span class="macro">assert_eq</span><span class="macro">!</span>(
    156. 

  156.     <span class="ident">s</span>.<span class="ident">each_variant</span>(<span class="op">|</span><span class="ident">v</span><span class="op">|</span> {
    157. 

  157.         <span class="kw">let</span> <span class="ident">name</span> <span class="op">=</span> <span class="kw-2">&amp;</span><span class="ident">v</span>.<span class="ident">ast</span>().<span class="ident">ident</span>;
    158. 

  158.         <span class="macro">quote</span><span class="macro">!</span>(<span class="macro">println</span><span class="macro">!</span>(<span class="macro">stringify</span><span class="macro">!</span>(#<span class="ident">name</span>)))
    159. 

  159.     }),
    160. 

  160. 

  161.     <span class="macro">quote</span><span class="macro">!</span>{
    162. 

  162.         <span class="ident">A</span>::<span class="ident">B</span>(<span class="kw-2">ref</span> <span class="ident">__binding_0</span>, <span class="kw-2">ref</span> <span class="ident">__binding_1</span>,) <span class="op">=&gt;</span> {
    163. 

  163.             <span class="macro">println</span><span class="macro">!</span>(<span class="macro">stringify</span><span class="macro">!</span>(<span class="ident">B</span>))
    164. 

  164.         }
    165. 

  165.         <span class="ident">A</span>::<span class="ident">C</span>(<span class="kw-2">ref</span> <span class="ident">__binding_0</span>,) <span class="op">=&gt;</span> {
    166. 

  166.             <span class="macro">println</span><span class="macro">!</span>(<span class="macro">stringify</span><span class="macro">!</span>(<span class="ident">C</span>))
    167. 

  167.         }
    168. 

  168.     }
    169. 

  169. );</pre>
    170. 

  170. </div><h4 id='method.filter' class="method"><span id='filter.v' class='invisible'><code>pub fn <a href='#method.filter' class='fnname'>filter</a>&lt;F&gt;(&amp;mut self, f: F) -&gt; <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&amp;mut </a>Self <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;F: <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/function/trait.FnMut.html" title="trait core::ops::function::FnMut">FnMut</a>(&amp;<a class="struct" href="../synstructure/struct.BindingInfo.html" title="struct synstructure::BindingInfo">BindingInfo</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a>,&nbsp;</span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/synstructure/lib.rs.html#1131-1139' title='goto source code'>[src]</a></span></h4>
    171. 

  171. <div class='docblock'><p>Filter the bindings created by this <code>Structure</code> object. This has 2 effects:</p>
    172. 

  172. <ul>
    173. 

  173. <li>
    174. 

  174. <p>The bindings will no longer appear in match arms generated by methods
    175. 

  175. on this <code>Structure</code> or its subobjects.</p>
    176. 

  176. </li>
    177. 

  177. <li>
    178. 

  178. <p>Impl blocks created with the <code>bound_impl</code> or <code>unsafe_bound_impl</code>
    179. 

  179. method only consider type parameters referenced in the types of
    180. 

  180. non-filtered fields.</p>
    181. 

  181. </li>
    182. 

  182. </ul>
    183. 

  183. <h1 id="example-3" class="section-header"><a href="#example-3">Example</a></h1>
    184. 

  184. <pre class="rust rust-example-rendered">
    185. 

  185. <span class="kw">let</span> <span class="ident">di</span> <span class="op">=</span> <span class="ident">syn</span>::<span class="ident">parse_derive_input</span>(<span class="string">r#&quot;
    186. 

  186.     enum A {
    187. 

  187.         B{ a: i32, b: i32 },
    188. 

  188.         C{ a: u32 },
    189. 

  189.     }
    190. 

  190. &quot;#</span>).<span class="ident">unwrap</span>();
    191. 

  191. <span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">s</span> <span class="op">=</span> <span class="ident">Structure</span>::<span class="ident">new</span>(<span class="kw-2">&amp;</span><span class="ident">di</span>);
    192. 

  192. 

  193. <span class="ident">s</span>.<span class="ident">filter</span>(<span class="op">|</span><span class="ident">bi</span><span class="op">|</span> { <span class="ident">bi</span>.<span class="ident">ast</span>().<span class="ident">ident</span> <span class="op">==</span> <span class="prelude-val">Some</span>(<span class="string">&quot;a&quot;</span>.<span class="ident">into</span>()) });
    194. 

  194. 

  195. <span class="macro">assert_eq</span><span class="macro">!</span>(
    196. 

  196.     <span class="ident">s</span>.<span class="ident">each</span>(<span class="op">|</span><span class="ident">bi</span><span class="op">|</span> <span class="macro">quote</span><span class="macro">!</span>(<span class="macro">println</span><span class="macro">!</span>(<span class="string">&quot;{:?}&quot;</span>, #<span class="ident">bi</span>))),
    197. 

  197. 

  198.     <span class="macro">quote</span><span class="macro">!</span>{
    199. 

  199.         <span class="ident">A</span>::<span class="ident">B</span>{ <span class="ident">a</span>: <span class="kw-2">ref</span> <span class="ident">__binding_0</span>, .. } <span class="op">=&gt;</span> {
    200. 

  200.             { <span class="macro">println</span><span class="macro">!</span>(<span class="string">&quot;{:?}&quot;</span>, <span class="ident">__binding_0</span>) }
    201. 

  201.         }
    202. 

  202.         <span class="ident">A</span>::<span class="ident">C</span>{ <span class="ident">a</span>: <span class="kw-2">ref</span> <span class="ident">__binding_0</span>, } <span class="op">=&gt;</span> {
    203. 

  203.             { <span class="macro">println</span><span class="macro">!</span>(<span class="string">&quot;{:?}&quot;</span>, <span class="ident">__binding_0</span>) }
    204. 

  204.         }
    205. 

  205.     }
    206. 

  206. );</pre>
    207. 

  207. </div><h4 id='method.filter_variants' class="method"><span id='filter_variants.v' class='invisible'><code>pub fn <a href='#method.filter_variants' class='fnname'>filter_variants</a>&lt;F&gt;(&amp;mut self, f: F) -&gt; <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&amp;mut </a>Self <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;F: <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/function/trait.FnMut.html" title="trait core::ops::function::FnMut">FnMut</a>(&amp;<a class="struct" href="../synstructure/struct.VariantInfo.html" title="struct synstructure::VariantInfo">VariantInfo</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a>,&nbsp;</span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/synstructure/lib.rs.html#1179-1189' title='goto source code'>[src]</a></span></h4>
    208. 

  208. <div class='docblock'><p>Filter the variants matched by this <code>Structure</code> object. This has 2 effects:</p>
    209. 

  209. <ul>
    210. 

  210. <li>
    211. 

  211. <p>Match arms destructuring these variants will no longer be generated by
    212. 

  212. methods on this <code>Structure</code></p>
    213. 

  213. </li>
    214. 

  214. <li>
    215. 

  215. <p>Impl blocks created with the <code>bound_impl</code> or <code>unsafe_bound_impl</code>
    216. 

  216. method only consider type parameters referenced in the types of
    217. 

  217. fields in non-fitered variants.</p>
    218. 

  218. </li>
    219. 

  219. </ul>
    220. 

  220. <h1 id="example-4" class="section-header"><a href="#example-4">Example</a></h1>
    221. 

  221. <pre class="rust rust-example-rendered">
    222. 

  222. <span class="kw">let</span> <span class="ident">di</span> <span class="op">=</span> <span class="ident">syn</span>::<span class="ident">parse_derive_input</span>(<span class="string">r#&quot;
    223. 

  223.     enum A {
    224. 

  224.         B(i32, i32),
    225. 

  225.         C(u32),
    226. 

  226.     }
    227. 

  227. &quot;#</span>).<span class="ident">unwrap</span>();
    228. 

  228. <span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">s</span> <span class="op">=</span> <span class="ident">Structure</span>::<span class="ident">new</span>(<span class="kw-2">&amp;</span><span class="ident">di</span>);
    229. 

  229. 

  230. <span class="ident">s</span>.<span class="ident">filter_variants</span>(<span class="op">|</span><span class="ident">v</span><span class="op">|</span> <span class="ident">v</span>.<span class="ident">ast</span>().<span class="ident">ident</span> <span class="op">!=</span> <span class="string">&quot;B&quot;</span>);
    231. 

  231. 

  232. <span class="macro">assert_eq</span><span class="macro">!</span>(
    233. 

  233.     <span class="ident">s</span>.<span class="ident">each</span>(<span class="op">|</span><span class="ident">bi</span><span class="op">|</span> <span class="macro">quote</span><span class="macro">!</span>(<span class="macro">println</span><span class="macro">!</span>(<span class="string">&quot;{:?}&quot;</span>, #<span class="ident">bi</span>))),
    234. 

  234. 

  235.     <span class="macro">quote</span><span class="macro">!</span>{
    236. 

  236.         <span class="ident">A</span>::<span class="ident">C</span>(<span class="kw-2">ref</span> <span class="ident">__binding_0</span>,) <span class="op">=&gt;</span> {
    237. 

  237.             { <span class="macro">println</span><span class="macro">!</span>(<span class="string">&quot;{:?}&quot;</span>, <span class="ident">__binding_0</span>) }
    238. 

  238.         }
    239. 

  239.         _ <span class="op">=&gt;</span> {}
    240. 

  240.     }
    241. 

  241. );</pre>
    242. 

  242. </div><h4 id='method.remove_variant' class="method"><span id='remove_variant.v' class='invisible'><code>pub fn <a href='#method.remove_variant' class='fnname'>remove_variant</a>(&amp;mut self, idx: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&amp;mut </a>Self</code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/synstructure/lib.rs.html#1196-1200' title='goto source code'>[src]</a></span></h4>
    243. 

  243. <div class='docblock'><p>Remove the variant at the given index.</p>
    244. 

  244. <h1 id="panics" class="section-header"><a href="#panics">Panics</a></h1>
    245. 

  245. <p>Panics if the index is out of range.</p>
    246. 

  246. </div><h4 id='method.bind_with' class="method"><span id='bind_with.v' class='invisible'><code>pub fn <a href='#method.bind_with' class='fnname'>bind_with</a>&lt;F&gt;(&amp;mut self, f: F) -&gt; <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&amp;mut </a>Self <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;F: <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/function/trait.FnMut.html" title="trait core::ops::function::FnMut">FnMut</a>(&amp;<a class="struct" href="../synstructure/struct.BindingInfo.html" title="struct synstructure::BindingInfo">BindingInfo</a>) -&gt; <a class="enum" href="../synstructure/enum.BindStyle.html" title="enum synstructure::BindStyle">BindStyle</a>,&nbsp;</span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/synstructure/lib.rs.html#1237-1245' title='goto source code'>[src]</a></span></h4>
    247. 

  247. <div class='docblock'><p>Updates the <code>BindStyle</code> for each of the passed-in fields by calling the
    248. 

  248. passed-in function for each <code>BindingInfo</code>.</p>
    249. 

  249. <h1 id="example-5" class="section-header"><a href="#example-5">Example</a></h1>
    250. 

  250. <pre class="rust rust-example-rendered">
    251. 

  251. <span class="kw">let</span> <span class="ident">di</span> <span class="op">=</span> <span class="ident">syn</span>::<span class="ident">parse_derive_input</span>(<span class="string">r#&quot;
    252. 

  252.     enum A {
    253. 

  253.         B(i32, i32),
    254. 

  254.         C(u32),
    255. 

  255.     }
    256. 

  256. &quot;#</span>).<span class="ident">unwrap</span>();
    257. 

  257. <span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">s</span> <span class="op">=</span> <span class="ident">Structure</span>::<span class="ident">new</span>(<span class="kw-2">&amp;</span><span class="ident">di</span>);
    258. 

  258. 

  259. <span class="ident">s</span>.<span class="ident">bind_with</span>(<span class="op">|</span><span class="ident">bi</span><span class="op">|</span> <span class="ident">BindStyle</span>::<span class="ident">RefMut</span>);
    260. 

  260. 

  261. <span class="macro">assert_eq</span><span class="macro">!</span>(
    262. 

  262.     <span class="ident">s</span>.<span class="ident">each</span>(<span class="op">|</span><span class="ident">bi</span><span class="op">|</span> <span class="macro">quote</span><span class="macro">!</span>(<span class="macro">println</span><span class="macro">!</span>(<span class="string">&quot;{:?}&quot;</span>, #<span class="ident">bi</span>))),
    263. 

  263. 

  264.     <span class="macro">quote</span><span class="macro">!</span>{
    265. 

  265.         <span class="ident">A</span>::<span class="ident">B</span>(<span class="kw-2">ref</span> <span class="kw-2">mut</span> <span class="ident">__binding_0</span>, <span class="kw-2">ref</span> <span class="kw-2">mut</span> <span class="ident">__binding_1</span>,) <span class="op">=&gt;</span> {
    266. 

  266.             { <span class="macro">println</span><span class="macro">!</span>(<span class="string">&quot;{:?}&quot;</span>, <span class="ident">__binding_0</span>) }
    267. 

  267.             { <span class="macro">println</span><span class="macro">!</span>(<span class="string">&quot;{:?}&quot;</span>, <span class="ident">__binding_1</span>) }
    268. 

  268.         }
    269. 

  269.         <span class="ident">A</span>::<span class="ident">C</span>(<span class="kw-2">ref</span> <span class="kw-2">mut</span> <span class="ident">__binding_0</span>,) <span class="op">=&gt;</span> {
    270. 

  270.             { <span class="macro">println</span><span class="macro">!</span>(<span class="string">&quot;{:?}&quot;</span>, <span class="ident">__binding_0</span>) }
    271. 

  271.         }
    272. 

  272.     }
    273. 

  273. );</pre>
    274. 

  274. </div><h4 id='method.binding_name' class="method"><span id='binding_name.v' class='invisible'><code>pub fn <a href='#method.binding_name' class='fnname'>binding_name</a>&lt;F&gt;(&amp;mut self, f: F) -&gt; <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&amp;mut </a>Self <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;F: <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/function/trait.FnMut.html" title="trait core::ops::function::FnMut">FnMut</a>(&amp;<a class="struct" href="../syn/data/struct.Field.html" title="struct syn::data::Field">Field</a>, <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>) -&gt; <a class="struct" href="../syn/ident/struct.Ident.html" title="struct syn::ident::Ident">Ident</a>,&nbsp;</span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/synstructure/lib.rs.html#1288-1296' title='goto source code'>[src]</a></span></h4>
    275. 

  275. <div class='docblock'><p>Updates the binding name for each fo the passed-in fields by calling the
    276. 

  276. passed-in function for each <code>BindingInfo</code>.</p>
    277. 

  277. <p>The function will be called with the <code>BindingInfo</code> and its index in the
    278. 

  278. enclosing variant.</p>
    279. 

  279. <p>The default name is <code>__binding_{}</code> where <code>{}</code> is replaced with an
    280. 

  280. increasing number.</p>
    281. 

  281. <h1 id="example-6" class="section-header"><a href="#example-6">Example</a></h1>
    282. 

  282. <pre class="rust rust-example-rendered">
    283. 

  283. <span class="kw">let</span> <span class="ident">di</span> <span class="op">=</span> <span class="ident">syn</span>::<span class="ident">parse_derive_input</span>(<span class="string">r#&quot;
    284. 

  284.     enum A {
    285. 

  285.         B{ a: i32, b: i32 },
    286. 

  286.         C{ a: u32 },
    287. 

  287.     }
    288. 

  288. &quot;#</span>).<span class="ident">unwrap</span>();
    289. 

  289. <span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">s</span> <span class="op">=</span> <span class="ident">Structure</span>::<span class="ident">new</span>(<span class="kw-2">&amp;</span><span class="ident">di</span>);
    290. 

  290. 

  291. <span class="ident">s</span>.<span class="ident">binding_name</span>(<span class="op">|</span><span class="ident">bi</span>, <span class="ident">i</span><span class="op">|</span> <span class="ident">bi</span>.<span class="ident">ident</span>.<span class="ident">clone</span>().<span class="ident">unwrap</span>());
    292. 

  292. 

  293. <span class="macro">assert_eq</span><span class="macro">!</span>(
    294. 

  294.     <span class="ident">s</span>.<span class="ident">each</span>(<span class="op">|</span><span class="ident">bi</span><span class="op">|</span> <span class="macro">quote</span><span class="macro">!</span>(<span class="macro">println</span><span class="macro">!</span>(<span class="string">&quot;{:?}&quot;</span>, #<span class="ident">bi</span>))),
    295. 

  295. 

  296.     <span class="macro">quote</span><span class="macro">!</span>{
    297. 

  297.         <span class="ident">A</span>::<span class="ident">B</span>{ <span class="ident">a</span>: <span class="kw-2">ref</span> <span class="ident">a</span>, <span class="ident">b</span>: <span class="kw-2">ref</span> <span class="ident">b</span>, } <span class="op">=&gt;</span> {
    298. 

  298.             { <span class="macro">println</span><span class="macro">!</span>(<span class="string">&quot;{:?}&quot;</span>, <span class="ident">a</span>) }
    299. 

  299.             { <span class="macro">println</span><span class="macro">!</span>(<span class="string">&quot;{:?}&quot;</span>, <span class="ident">b</span>) }
    300. 

  300.         }
    301. 

  301.         <span class="ident">A</span>::<span class="ident">C</span>{ <span class="ident">a</span>: <span class="kw-2">ref</span> <span class="ident">a</span>, } <span class="op">=&gt;</span> {
    302. 

  302.             { <span class="macro">println</span><span class="macro">!</span>(<span class="string">&quot;{:?}&quot;</span>, <span class="ident">a</span>) }
    303. 

  303.         }
    304. 

  304.     }
    305. 

  305. );</pre>
    306. 

  306. </div><h4 id='method.referenced_ty_params' class="method"><span id='referenced_ty_params.v' class='invisible'><code>pub fn <a href='#method.referenced_ty_params' class='fnname'>referenced_ty_params</a>(&amp;self) -&gt; <a class="struct" href="https://doc.rust-lang.org/nightly/alloc/vec/struct.Vec.html" title="struct alloc::vec::Vec">Vec</a>&lt;&amp;'a <a class="struct" href="../syn/ident/struct.Ident.html" title="struct syn::ident::Ident">Ident</a>&gt;</code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/synstructure/lib.rs.html#1330-1338' title='goto source code'>[src]</a></span></h4>
    307. 

  307. <div class='docblock'><p>Returns a list of the type parameters which are refrenced in the types
    308. 

  308. of non-filtered fields / variants.</p>
    309. 

  309. <h1 id="caveat" class="section-header"><a href="#caveat">Caveat</a></h1>
    310. 

  310. <p>If the struct contains any macros in type position, all parameters will
    311. 

  311. be considered bound. This is because we cannot determine which type
    312. 

  312. parameters are bound by type macros.</p>
    313. 

  313. <h1 id="example-7" class="section-header"><a href="#example-7">Example</a></h1>
    314. 

  314. <pre class="rust rust-example-rendered">
    315. 

  315. <span class="kw">let</span> <span class="ident">di</span> <span class="op">=</span> <span class="ident">syn</span>::<span class="ident">parse_derive_input</span>(<span class="string">r#&quot;
    316. 

  316.     enum A&lt;T, U&gt; {
    317. 

  317.         B(T, i32),
    318. 

  318.         C(Option&lt;U&gt;),
    319. 

  319.     }
    320. 

  320. &quot;#</span>).<span class="ident">unwrap</span>();
    321. 

  321. <span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">s</span> <span class="op">=</span> <span class="ident">Structure</span>::<span class="ident">new</span>(<span class="kw-2">&amp;</span><span class="ident">di</span>);
    322. 

  322. 

  323. <span class="ident">s</span>.<span class="ident">filter_variants</span>(<span class="op">|</span><span class="ident">v</span><span class="op">|</span> <span class="ident">v</span>.<span class="ident">ast</span>().<span class="ident">ident</span> <span class="op">!=</span> <span class="string">&quot;C&quot;</span>);
    324. 

  324. 

  325. <span class="macro">assert_eq</span><span class="macro">!</span>(
    326. 

  326.     <span class="ident">s</span>.<span class="ident">referenced_ty_params</span>(),
    327. 

  327.     <span class="kw-2">&amp;</span>[<span class="kw-2">&amp;</span>(<span class="ident">syn</span>::<span class="ident">Ident</span>::<span class="ident">from</span>(<span class="string">&quot;T&quot;</span>))]
    328. 

  328. );</pre>
    329. 

  329. </div><h4 id='method.add_trait_bounds' class="method"><span id='add_trait_bounds.v' class='invisible'><code>pub fn <a href='#method.add_trait_bounds' class='fnname'>add_trait_bounds</a>(<br>&nbsp;&nbsp;&nbsp;&nbsp;&amp;self, <br>&nbsp;&nbsp;&nbsp;&nbsp;bound: &amp;<a class="enum" href="../syn/generics/enum.TyParamBound.html" title="enum syn::generics::TyParamBound">TyParamBound</a>, <br>&nbsp;&nbsp;&nbsp;&nbsp;preds: &amp;mut <a class="struct" href="https://doc.rust-lang.org/nightly/alloc/vec/struct.Vec.html" title="struct alloc::vec::Vec">Vec</a>&lt;<a class="enum" href="../syn/generics/enum.WherePredicate.html" title="enum syn::generics::WherePredicate">WherePredicate</a>&gt;<br>)</code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/synstructure/lib.rs.html#1348-1373' title='goto source code'>[src]</a></span></h4>
    330. 

  330. <div class='docblock'><p>Add trait bounds for a trait with the given path for each type parmaeter
    331. 

  331. referenced in the types of non-filtered fields.</p>
    332. 

  332. <h1 id="caveat-1" class="section-header"><a href="#caveat-1">Caveat</a></h1>
    333. 

  333. <p>If the method contains any macros in type position, all parameters will
    334. 

  334. be considered bound. This is because we cannot determine which type
    335. 

  335. parameters are bound by type macros.</p>
    336. 

  336. </div><h4 id='method.bound_impl' class="method"><span id='bound_impl.v' class='invisible'><code>pub fn <a href='#method.bound_impl' class='fnname'>bound_impl</a>&lt;P:&nbsp;<a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.AsRef.html" title="trait core::convert::AsRef">AsRef</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.str.html">str</a>&gt;, B:&nbsp;<a class="trait" href="../quote/to_tokens/trait.ToTokens.html" title="trait quote::to_tokens::ToTokens">ToTokens</a>&gt;(<br>&nbsp;&nbsp;&nbsp;&nbsp;&amp;self, <br>&nbsp;&nbsp;&nbsp;&nbsp;bound: P, <br>&nbsp;&nbsp;&nbsp;&nbsp;body: B<br>) -&gt; <a class="struct" href="../quote/tokens/struct.Tokens.html" title="struct quote::tokens::Tokens">Tokens</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/synstructure/lib.rs.html#1423-1438' title='goto source code'>[src]</a></span></h4>
    337. 

  337. <div class='docblock'><p>Creates an <code>impl</code> block with the required generic type fields filled in
    338. 

  338. to implement the trait <code>path</code>.</p>
    339. 

  339. <p>This method also adds where clauses to the impl requiring that all
    340. 

  340. referenced type parmaeters implement the trait <code>path</code>.</p>
    341. 

  341. <h1 id="caveat-2" class="section-header"><a href="#caveat-2">Caveat</a></h1>
    342. 

  342. <p>If the method contains any macros in type position, all parameters will
    343. 

  343. be considered bound. This is because we cannot determine which type
    344. 

  344. parameters are bound by type macros.</p>
    345. 

  345. <h1 id="panics-1" class="section-header"><a href="#panics-1">Panics</a></h1>
    346. 

  346. <p>Panics if the path string parameter is not a valid TyParamBound.</p>
    347. 

  347. <h1 id="example-8" class="section-header"><a href="#example-8">Example</a></h1>
    348. 

  348. <pre class="rust rust-example-rendered">
    349. 

  349. <span class="kw">let</span> <span class="ident">di</span> <span class="op">=</span> <span class="ident">syn</span>::<span class="ident">parse_derive_input</span>(<span class="string">r#&quot;
    350. 

  350.     enum A&lt;T, U&gt; {
    351. 

  351.         B(T),
    352. 

  352.         C(Option&lt;U&gt;),
    353. 

  353.     }
    354. 

  354. &quot;#</span>).<span class="ident">unwrap</span>();
    355. 

  355. <span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">s</span> <span class="op">=</span> <span class="ident">Structure</span>::<span class="ident">new</span>(<span class="kw-2">&amp;</span><span class="ident">di</span>);
    356. 

  356. 

  357. <span class="ident">s</span>.<span class="ident">filter_variants</span>(<span class="op">|</span><span class="ident">v</span><span class="op">|</span> <span class="ident">v</span>.<span class="ident">ast</span>().<span class="ident">ident</span> <span class="op">!=</span> <span class="string">&quot;B&quot;</span>);
    358. 

  358. 

  359. <span class="macro">assert_eq</span><span class="macro">!</span>(
    360. 

  360.     <span class="ident">s</span>.<span class="ident">bound_impl</span>(<span class="string">&quot;::krate::Trait&quot;</span>, <span class="macro">quote</span><span class="macro">!</span>{
    361. 

  361.         <span class="kw">fn</span> <span class="ident">a</span>() {}
    362. 

  362.     }),
    363. 

  363.     <span class="macro">quote</span><span class="macro">!</span>{
    364. 

  364.         <span class="kw">impl</span><span class="op">&lt;</span><span class="ident">T</span>, <span class="ident">U</span><span class="op">&gt;</span> ::<span class="ident">krate</span>::<span class="ident">Trait</span> <span class="kw">for</span> <span class="ident">A</span><span class="op">&lt;</span><span class="ident">T</span>, <span class="ident">U</span><span class="op">&gt;</span>
    365. 

  365.             <span class="kw">where</span> <span class="prelude-ty">Option</span><span class="op">&lt;</span><span class="ident">U</span><span class="op">&gt;</span>: ::<span class="ident">krate</span>::<span class="ident">Trait</span>,
    366. 

  366.                   <span class="ident">U</span>: ::<span class="ident">krate</span>::<span class="ident">Trait</span>
    367. 

  367.         {
    368. 

  368.             <span class="kw">fn</span> <span class="ident">a</span>() {}
    369. 

  369.         }
    370. 

  370.     }
    371. 

  371. );</pre>
    372. 

  372. </div><h4 id='method.unsafe_bound_impl' class="method"><span id='unsafe_bound_impl.v' class='invisible'><code>pub fn <a href='#method.unsafe_bound_impl' class='fnname'>unsafe_bound_impl</a>&lt;P:&nbsp;<a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.AsRef.html" title="trait core::convert::AsRef">AsRef</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.str.html">str</a>&gt;, B:&nbsp;<a class="trait" href="../quote/to_tokens/trait.ToTokens.html" title="trait quote::to_tokens::ToTokens">ToTokens</a>&gt;(<br>&nbsp;&nbsp;&nbsp;&nbsp;&amp;self, <br>&nbsp;&nbsp;&nbsp;&nbsp;path: P, <br>&nbsp;&nbsp;&nbsp;&nbsp;body: B<br>) -&gt; <a class="struct" href="../quote/tokens/struct.Tokens.html" title="struct quote::tokens::Tokens">Tokens</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/synstructure/lib.rs.html#1442-1445' title='goto source code'>[src]</a></span></h4>
    373. 

  373. <div class='docblock'><p>This method is the same as <code>bound_impl</code>, except also includes the
    374. 

  374. <code>unsafe</code> keyword for implementing unsafe traits.</p>
    375. 

  375. </div><h4 id='method.unbound_impl' class="method"><span id='unbound_impl.v' class='invisible'><code>pub fn <a href='#method.unbound_impl' class='fnname'>unbound_impl</a>&lt;P:&nbsp;<a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.AsRef.html" title="trait core::convert::AsRef">AsRef</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.str.html">str</a>&gt;, B:&nbsp;<a class="trait" href="../quote/to_tokens/trait.ToTokens.html" title="trait quote::to_tokens::ToTokens">ToTokens</a>&gt;(<br>&nbsp;&nbsp;&nbsp;&nbsp;&amp;self, <br>&nbsp;&nbsp;&nbsp;&nbsp;bound: P, <br>&nbsp;&nbsp;&nbsp;&nbsp;body: B<br>) -&gt; <a class="struct" href="../quote/tokens/struct.Tokens.html" title="struct quote::tokens::Tokens">Tokens</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/synstructure/lib.rs.html#1449-1461' title='goto source code'>[src]</a></span></h4>
    376. 

  376. <div class='docblock'><p>This method is like <code>bound_impl</code> but doesn't add the additional bounds
    377. 

  377. to the where clause.</p>
    378. 

  378. </div><h4 id='method.unsafe_unbound_impl' class="method"><span id='unsafe_unbound_impl.v' class='invisible'><code>pub fn <a href='#method.unsafe_unbound_impl' class='fnname'>unsafe_unbound_impl</a>&lt;P:&nbsp;<a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.AsRef.html" title="trait core::convert::AsRef">AsRef</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.str.html">str</a>&gt;, B:&nbsp;<a class="trait" href="../quote/to_tokens/trait.ToTokens.html" title="trait quote::to_tokens::ToTokens">ToTokens</a>&gt;(<br>&nbsp;&nbsp;&nbsp;&nbsp;&amp;self, <br>&nbsp;&nbsp;&nbsp;&nbsp;path: P, <br>&nbsp;&nbsp;&nbsp;&nbsp;body: B<br>) -&gt; <a class="struct" href="../quote/tokens/struct.Tokens.html" title="struct quote::tokens::Tokens">Tokens</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/synstructure/lib.rs.html#1465-1468' title='goto source code'>[src]</a></span></h4>
    379. 

  379. <div class='docblock'><p>This method is the same as <code>unbound_impl</code>, except also includes the
    380. 

  380. <code>unsafe</code> keyword for implementing unsafe traits.</p>
    381. 

  381. </div></div>
    382. 

  382.             <h2 id='implementations' class='small-section-header'>
    383. 

  383.               Trait Implementations<a href='#implementations' class='anchor'></a>
    384. 

  384.             </h2>
    385. 

  385.         <h3 id='impl-Debug' class='impl'><span class='in-band'><code>impl&lt;'a&gt; <a class="trait" href="https://doc.rust-lang.org/nightly/core/fmt/trait.Debug.html" title="trait core::fmt::Debug">Debug</a> for <a class="struct" href="../synstructure/struct.Structure.html" title="struct synstructure::Structure">Structure</a>&lt;'a&gt;</code><a href='#impl-Debug' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/synstructure/lib.rs.html#858' title='goto source code'>[src]</a></span></h3>
    386. 

  386. <div class='impl-items'><h4 id='method.fmt' class="method"><span id='fmt.v' class='invisible'><code>fn <a href='https://doc.rust-lang.org/nightly/core/fmt/trait.Debug.html#tymethod.fmt' class='fnname'>fmt</a>(&amp;self, __arg_0: &amp;mut <a class="struct" href="https://doc.rust-lang.org/nightly/core/fmt/struct.Formatter.html" title="struct core::fmt::Formatter">Formatter</a>) -&gt; <a class="type" href="https://doc.rust-lang.org/nightly/core/fmt/type.Result.html" title="type core::fmt::Result">Result</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/synstructure/lib.rs.html#858' title='goto source code'>[src]</a></span></h4>
    387. 

  387. <div class='docblock'><p>Formats the value using the given formatter. <a href="https://doc.rust-lang.org/nightly/core/fmt/trait.Debug.html#tymethod.fmt">Read more</a></p>
    388. 

  388. </div></div><h3 id='impl-Clone' class='impl'><span class='in-band'><code>impl&lt;'a&gt; <a class="trait" href="https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a> for <a class="struct" href="../synstructure/struct.Structure.html" title="struct synstructure::Structure">Structure</a>&lt;'a&gt;</code><a href='#impl-Clone' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/synstructure/lib.rs.html#858' title='goto source code'>[src]</a></span></h3>
    389. 

  389. <div class='impl-items'><h4 id='method.clone' class="method"><span id='clone.v' class='invisible'><code>fn <a href='https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html#tymethod.clone' class='fnname'>clone</a>(&amp;self) -&gt; <a class="struct" href="../synstructure/struct.Structure.html" title="struct synstructure::Structure">Structure</a>&lt;'a&gt;</code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/synstructure/lib.rs.html#858' title='goto source code'>[src]</a></span></h4>
    390. 

  390. <div class='docblock'><p>Returns a copy of the value. <a href="https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html#tymethod.clone">Read more</a></p>
    391. 

  391. </div><h4 id='method.clone_from' class="method"><span id='clone_from.v' class='invisible'><code>fn <a href='https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html#method.clone_from' class='fnname'>clone_from</a>(&amp;mut self, source: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&amp;</a>Self)</code></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.0.0'>1.0.0</div><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/clone.rs.html#112-114' title='goto source code'>[src]</a></span></h4>
    392. 

  392. <div class='docblock'><p>Performs copy-assignment from <code>source</code>. <a href="https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html#method.clone_from">Read more</a></p>
    393. 

  393. </div></div><h3 id='impl-PartialEq' class='impl'><span class='in-band'><code>impl&lt;'a&gt; <a class="trait" href="https://doc.rust-lang.org/nightly/core/cmp/trait.PartialEq.html" title="trait core::cmp::PartialEq">PartialEq</a> for <a class="struct" href="../synstructure/struct.Structure.html" title="struct synstructure::Structure">Structure</a>&lt;'a&gt;</code><a href='#impl-PartialEq' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/synstructure/lib.rs.html#858' title='goto source code'>[src]</a></span></h3>
    394. 

  394. <div class='impl-items'><h4 id='method.eq' class="method"><span id='eq.v' class='invisible'><code>fn <a href='https://doc.rust-lang.org/nightly/core/cmp/trait.PartialEq.html#tymethod.eq' class='fnname'>eq</a>(&amp;self, __arg_0: &amp;<a class="struct" href="../synstructure/struct.Structure.html" title="struct synstructure::Structure">Structure</a>&lt;'a&gt;) -&gt; <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/synstructure/lib.rs.html#858' title='goto source code'>[src]</a></span></h4>
    395. 

  395. <div class='docblock'><p>This method tests for <code>self</code> and <code>other</code> values to be equal, and is used by <code>==</code>. <a href="https://doc.rust-lang.org/nightly/core/cmp/trait.PartialEq.html#tymethod.eq">Read more</a></p>
    396. 

  396. </div><h4 id='method.ne' class="method"><span id='ne.v' class='invisible'><code>fn <a href='https://doc.rust-lang.org/nightly/core/cmp/trait.PartialEq.html#method.ne' class='fnname'>ne</a>(&amp;self, __arg_0: &amp;<a class="struct" href="../synstructure/struct.Structure.html" title="struct synstructure::Structure">Structure</a>&lt;'a&gt;) -&gt; <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/synstructure/lib.rs.html#858' title='goto source code'>[src]</a></span></h4>
    397. 

  397. <div class='docblock'><p>This method tests for <code>!=</code>.</p>
    398. 

  398. </div></div><h3 id='impl-Eq' class='impl'><span class='in-band'><code>impl&lt;'a&gt; <a class="trait" href="https://doc.rust-lang.org/nightly/core/cmp/trait.Eq.html" title="trait core::cmp::Eq">Eq</a> for <a class="struct" href="../synstructure/struct.Structure.html" title="struct synstructure::Structure">Structure</a>&lt;'a&gt;</code><a href='#impl-Eq' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/synstructure/lib.rs.html#858' title='goto source code'>[src]</a></span></h3>
    399. 

  399. <div class='impl-items'></div><h3 id='impl-Hash' class='impl'><span class='in-band'><code>impl&lt;'a&gt; <a class="trait" href="https://doc.rust-lang.org/nightly/core/hash/trait.Hash.html" title="trait core::hash::Hash">Hash</a> for <a class="struct" href="../synstructure/struct.Structure.html" title="struct synstructure::Structure">Structure</a>&lt;'a&gt;</code><a href='#impl-Hash' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/synstructure/lib.rs.html#858' title='goto source code'>[src]</a></span></h3>
    400. 

  400. <div class='impl-items'><h4 id='method.hash' class="method"><span id='hash.v' class='invisible'><code>fn <a href='https://doc.rust-lang.org/nightly/core/hash/trait.Hash.html#tymethod.hash' class='fnname'>hash</a>&lt;__H:&nbsp;<a class="trait" href="https://doc.rust-lang.org/nightly/core/hash/trait.Hasher.html" title="trait core::hash::Hasher">Hasher</a>&gt;(&amp;self, __arg_0: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&amp;mut </a>__H)</code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/synstructure/lib.rs.html#858' title='goto source code'>[src]</a></span></h4>
    401. 

  401. <div class='docblock'><p>Feeds this value into the given [<code>Hasher</code>]. <a href="https://doc.rust-lang.org/nightly/core/hash/trait.Hash.html#tymethod.hash">Read more</a></p>
    402. 

  402. </div><h4 id='method.hash_slice' class="method"><span id='hash_slice.v' class='invisible'><code>fn <a href='https://doc.rust-lang.org/nightly/core/hash/trait.Hash.html#method.hash_slice' class='fnname'>hash_slice</a>&lt;H&gt;(data: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">&amp;[Self]</a>, state: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&amp;mut </a>H) <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;H: <a class="trait" href="https://doc.rust-lang.org/nightly/core/hash/trait.Hasher.html" title="trait core::hash::Hasher">Hasher</a>,&nbsp;</span></code></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.3.0'>1.3.0</div><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/hash/mod.rs.html#202-208' title='goto source code'>[src]</a></span></h4>
    403. 

  403. <div class='docblock'><p>Feeds a slice of this type into the given [<code>Hasher</code>]. <a href="https://doc.rust-lang.org/nightly/core/hash/trait.Hash.html#method.hash_slice">Read more</a></p>
    404. 

  404. </div></div></section>
    405. 

  405.     <section id='search' class="content hidden"></section>
    406. 

  406. 

  407.     <section class="footer"></section>
    408. 

  408. 

  409.     <aside id="help" class="hidden">
    410. 

  410.         <div>
    411. 

  411.             <h1 class="hidden">Help</h1>
    412. 

  412. 

  413.             <div class="shortcuts">
    414. 

  414.                 <h2>Keyboard Shortcuts</h2>
    415. 

  415. 

  416.                 <dl>
    417. 

  417.                     <dt><kbd>?</kbd></dt>
    418. 

  418.                     <dd>Show this help dialog</dd>
    419. 

  419.                     <dt><kbd>S</kbd></dt>
    420. 

  420.                     <dd>Focus the search field</dd>
    421. 

  421.                     <dt><kbd>↑</kbd></dt>
    422. 

  422.                     <dd>Move up in search results</dd>
    423. 

  423.                     <dt><kbd>↓</kbd></dt>
    424. 

  424.                     <dd>Move down in search results</dd>
    425. 

  425.                     <dt><kbd>↹</kbd></dt>
    426. 

  426.                     <dd>Switch tab</dd>
    427. 

  427.                     <dt><kbd>&#9166;</kbd></dt>
    428. 

  428.                     <dd>Go to active search result</dd>
    429. 

  429.                     <dt><kbd>+</kbd></dt>
    430. 

  430.                     <dd>Expand all sections</dd>
    431. 

  431.                     <dt><kbd>-</kbd></dt>
    432. 

  432.                     <dd>Collapse all sections</dd>
    433. 

  433.                 </dl>
    434. 

  434.             </div>
    435. 

  435. 

  436.             <div class="infos">
    437. 

  437.                 <h2>Search Tricks</h2>
    438. 

  438. 

  439.                 <p>
    440. 

  440.                     Prefix searches with a type followed by a colon (e.g.
    441. 

  441.                     <code>fn:</code>) to restrict the search to a given type.
    442. 

  442.                 </p>
    443. 

  443. 

  444.                 <p>
    445. 

  445.                     Accepted types are: <code>fn</code>, <code>mod</code>,
    446. 

  446.                     <code>struct</code>, <code>enum</code>,
    447. 

  447.                     <code>trait</code>, <code>type</code>, <code>macro</code>,
    448. 

  448.                     and <code>const</code>.
    449. 

  449.                 </p>
    450. 

  450. 

  451.                 <p>
    452. 

  452.                     Search functions by type signature (e.g.
    453. 

  453.                     <code>vec -> usize</code> or <code>* -> vec</code>)
    454. 

  454.                 </p>
    455. 

  455.             </div>
    456. 

  456.         </div>
    457. 

  457.     </aside>
    458. 

  458. 

  459.     
    460. 

  460. 

  461.     <script>
    462. 

  462.         window.rootPath = "../";
    463. 

  463.         window.currentCrate = "synstructure";
    464. 

  464.     </script>
    465. 

  465.     <script src="../main.js"></script>
    466. 

  466.     <script defer src="../search-index.js"></script>
    467. 

  467. </body>
    468. 

  468. </html>
    469.