Adding large folders

This commit is contained in:
2026-02-26 12:00:21 -05:00
parent 5400d82acd
commit 49701c85ad
47332 changed files with 1942573 additions and 0 deletions
+196
View File
@@ -0,0 +1,196 @@
<!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 of the Rust file `/home/newkirk/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/nom-8.0.0/src/bits/complete.rs`."><title>complete.rs - source</title><script>if(window.location.protocol!=="file:")document.head.insertAdjacentHTML("beforeend","SourceSerif4-Regular-6b053e98.ttf.woff2,FiraSans-Italic-81dc35de.woff2,FiraSans-Regular-0fe48ade.woff2,FiraSans-MediumItalic-ccf7e434.woff2,FiraSans-Medium-e1aa3f0a.woff2,SourceCodePro-Regular-8badfe75.ttf.woff2,SourceCodePro-Semibold-aa29a496.ttf.woff2".split(",").map(f=>`<link rel="preload" as="font" type="font/woff2"href="../../../static.files/${f}">`).join(""))</script><link rel="stylesheet" href="../../../static.files/normalize-9960930a.css"><link rel="stylesheet" href="../../../static.files/rustdoc-ca0dd0c4.css"><meta name="rustdoc-vars" data-root-path="../../../" data-static-root-path="../../../static.files/" data-current-crate="nom" data-themes="" data-resource-suffix="" data-rustdoc-version="1.93.1 (01f6ddf75 2026-02-11) (Arch Linux rust 1:1.93.1-1)" data-channel="1.93.1" data-search-js="search-9e2438ea.js" data-stringdex-js="stringdex-a3946164.js" data-settings-js="settings-c38705f0.js" ><script src="../../../static.files/storage-e2aeef58.js"></script><script defer src="../../../static.files/src-script-813739b1.js"></script><script defer src="../../../src-files.js"></script><script defer src="../../../static.files/main-a410ff4d.js"></script><noscript><link rel="stylesheet" href="../../../static.files/noscript-263c88ec.css"></noscript><link rel="alternate icon" type="image/png" href="../../../static.files/favicon-32x32-eab170b8.png"><link rel="icon" type="image/svg+xml" href="../../../static.files/favicon-044be391.svg"></head><body class="rustdoc src"><!--[if lte IE 11]><div class="warning">This old browser is unsupported and will most likely display funky things.</div><![endif]--><nav class="sidebar"><div class="src-sidebar-title"><h2>Files</h2></div></nav><div class="sidebar-resizer" title="Drag to resize sidebar"></div><main><section id="main-content" class="content"><div class="main-heading"><h1><div class="sub-heading">nom/bits/</div>complete.rs</h1><rustdoc-toolbar></rustdoc-toolbar></div><div class="example-wrap digits-3"><pre class="rust"><code><a href=#1 id=1 data-nosnippet>1</a><span class="doccomment">//! Bit level parsers
<a href=#2 id=2 data-nosnippet>2</a>//!
<a href=#3 id=3 data-nosnippet>3</a>
<a href=#4 id=4 data-nosnippet>4</a></span><span class="kw">use </span><span class="kw">crate</span>::error::{ErrorKind, ParseError};
<a href=#5 id=5 data-nosnippet>5</a><span class="kw">use </span><span class="kw">crate</span>::internal::{<span class="prelude-val">Err</span>, IResult};
<a href=#6 id=6 data-nosnippet>6</a><span class="kw">use </span><span class="kw">crate</span>::lib::std::ops::{AddAssign, Div, Shl, Shr};
<a href=#7 id=7 data-nosnippet>7</a><span class="kw">use </span><span class="kw">crate</span>::traits::{Input, ToUsize};
<a href=#8 id=8 data-nosnippet>8</a>
<a href=#9 id=9 data-nosnippet>9</a><span class="doccomment">/// Generates a parser taking `count` bits
<a href=#10 id=10 data-nosnippet>10</a>///
<a href=#11 id=11 data-nosnippet>11</a>/// # Example
<a href=#12 id=12 data-nosnippet>12</a>/// ```rust
<a href=#13 id=13 data-nosnippet>13</a>/// # use nom::bits::complete::take;
<a href=#14 id=14 data-nosnippet>14</a>/// # use nom::IResult;
<a href=#15 id=15 data-nosnippet>15</a>/// # use nom::error::{Error, ErrorKind};
<a href=#16 id=16 data-nosnippet>16</a>/// // Input is a tuple of (input: I, bit_offset: usize)
<a href=#17 id=17 data-nosnippet>17</a>/// fn parser(input: (&amp;[u8], usize), count: usize)-&gt; IResult&lt;(&amp;[u8], usize), u8&gt; {
<a href=#18 id=18 data-nosnippet>18</a>/// take(count)(input)
<a href=#19 id=19 data-nosnippet>19</a>/// }
<a href=#20 id=20 data-nosnippet>20</a>///
<a href=#21 id=21 data-nosnippet>21</a>/// // Consumes 0 bits, returns 0
<a href=#22 id=22 data-nosnippet>22</a>/// assert_eq!(parser(([0b00010010].as_ref(), 0), 0), Ok((([0b00010010].as_ref(), 0), 0)));
<a href=#23 id=23 data-nosnippet>23</a>///
<a href=#24 id=24 data-nosnippet>24</a>/// // Consumes 4 bits, returns their values and increase offset to 4
<a href=#25 id=25 data-nosnippet>25</a>/// assert_eq!(parser(([0b00010010].as_ref(), 0), 4), Ok((([0b00010010].as_ref(), 4), 0b00000001)));
<a href=#26 id=26 data-nosnippet>26</a>///
<a href=#27 id=27 data-nosnippet>27</a>/// // Consumes 4 bits, offset is 4, returns their values and increase offset to 0 of next byte
<a href=#28 id=28 data-nosnippet>28</a>/// assert_eq!(parser(([0b00010010].as_ref(), 4), 4), Ok((([].as_ref(), 0), 0b00000010)));
<a href=#29 id=29 data-nosnippet>29</a>///
<a href=#30 id=30 data-nosnippet>30</a>/// // Tries to consume 12 bits but only 8 are available
<a href=#31 id=31 data-nosnippet>31</a>/// assert_eq!(parser(([0b00010010].as_ref(), 0), 12), Err(nom::Err::Error(Error{input: ([0b00010010].as_ref(), 0), code: ErrorKind::Eof })));
<a href=#32 id=32 data-nosnippet>32</a>/// ```
<a href=#33 id=33 data-nosnippet>33</a></span><span class="kw">pub fn </span>take&lt;I, O, C, E: ParseError&lt;(I, usize)&gt;&gt;(
<a href=#34 id=34 data-nosnippet>34</a> count: C,
<a href=#35 id=35 data-nosnippet>35</a>) -&gt; <span class="kw">impl </span>Fn((I, usize)) -&gt; IResult&lt;(I, usize), O, E&gt;
<a href=#36 id=36 data-nosnippet>36</a><span class="kw">where
<a href=#37 id=37 data-nosnippet>37</a> </span>I: Input&lt;Item = u8&gt;,
<a href=#38 id=38 data-nosnippet>38</a> C: ToUsize,
<a href=#39 id=39 data-nosnippet>39</a> O: From&lt;u8&gt; + AddAssign + Shl&lt;usize, Output = O&gt; + Shr&lt;usize, Output = O&gt;,
<a href=#40 id=40 data-nosnippet>40</a>{
<a href=#41 id=41 data-nosnippet>41</a> <span class="kw">let </span>count = count.to_usize();
<a href=#42 id=42 data-nosnippet>42</a> <span class="kw">move </span>|(input, bit_offset): (I, usize)| {
<a href=#43 id=43 data-nosnippet>43</a> <span class="kw">if </span>count == <span class="number">0 </span>{
<a href=#44 id=44 data-nosnippet>44</a> <span class="prelude-val">Ok</span>(((input, bit_offset), <span class="number">0u8</span>.into()))
<a href=#45 id=45 data-nosnippet>45</a> } <span class="kw">else if </span>input.input_len() * <span class="number">8 </span>&lt; count + bit_offset {
<a href=#46 id=46 data-nosnippet>46</a> <span class="prelude-val">Err</span>(Err::Error(E::from_error_kind(
<a href=#47 id=47 data-nosnippet>47</a> (input, bit_offset),
<a href=#48 id=48 data-nosnippet>48</a> ErrorKind::Eof,
<a href=#49 id=49 data-nosnippet>49</a> )))
<a href=#50 id=50 data-nosnippet>50</a> } <span class="kw">else </span>{
<a href=#51 id=51 data-nosnippet>51</a> <span class="kw">let </span>cnt = (count + bit_offset).div(<span class="number">8</span>);
<a href=#52 id=52 data-nosnippet>52</a> <span class="kw">let </span><span class="kw-2">mut </span>acc: O = <span class="number">0_u8</span>.into();
<a href=#53 id=53 data-nosnippet>53</a> <span class="kw">let </span><span class="kw-2">mut </span>offset: usize = bit_offset;
<a href=#54 id=54 data-nosnippet>54</a> <span class="kw">let </span><span class="kw-2">mut </span>remaining: usize = count;
<a href=#55 id=55 data-nosnippet>55</a> <span class="kw">let </span><span class="kw-2">mut </span>end_offset: usize = <span class="number">0</span>;
<a href=#56 id=56 data-nosnippet>56</a>
<a href=#57 id=57 data-nosnippet>57</a> <span class="kw">for </span>byte <span class="kw">in </span>input.iter_elements().take(cnt + <span class="number">1</span>) {
<a href=#58 id=58 data-nosnippet>58</a> <span class="kw">if </span>remaining == <span class="number">0 </span>{
<a href=#59 id=59 data-nosnippet>59</a> <span class="kw">break</span>;
<a href=#60 id=60 data-nosnippet>60</a> }
<a href=#61 id=61 data-nosnippet>61</a> <span class="kw">let </span>val: O = <span class="kw">if </span>offset == <span class="number">0 </span>{
<a href=#62 id=62 data-nosnippet>62</a> byte.into()
<a href=#63 id=63 data-nosnippet>63</a> } <span class="kw">else </span>{
<a href=#64 id=64 data-nosnippet>64</a> ((byte &lt;&lt; offset) &gt;&gt; offset).into()
<a href=#65 id=65 data-nosnippet>65</a> };
<a href=#66 id=66 data-nosnippet>66</a>
<a href=#67 id=67 data-nosnippet>67</a> <span class="kw">if </span>remaining &lt; <span class="number">8 </span>- offset {
<a href=#68 id=68 data-nosnippet>68</a> acc += val &gt;&gt; (<span class="number">8 </span>- offset - remaining);
<a href=#69 id=69 data-nosnippet>69</a> end_offset = remaining + offset;
<a href=#70 id=70 data-nosnippet>70</a> <span class="kw">break</span>;
<a href=#71 id=71 data-nosnippet>71</a> } <span class="kw">else </span>{
<a href=#72 id=72 data-nosnippet>72</a> acc += val &lt;&lt; (remaining - (<span class="number">8 </span>- offset));
<a href=#73 id=73 data-nosnippet>73</a> remaining -= <span class="number">8 </span>- offset;
<a href=#74 id=74 data-nosnippet>74</a> offset = <span class="number">0</span>;
<a href=#75 id=75 data-nosnippet>75</a> }
<a href=#76 id=76 data-nosnippet>76</a> }
<a href=#77 id=77 data-nosnippet>77</a> <span class="prelude-val">Ok</span>(((input.take_from(cnt), end_offset), acc))
<a href=#78 id=78 data-nosnippet>78</a> }
<a href=#79 id=79 data-nosnippet>79</a> }
<a href=#80 id=80 data-nosnippet>80</a>}
<a href=#81 id=81 data-nosnippet>81</a>
<a href=#82 id=82 data-nosnippet>82</a><span class="doccomment">/// Generates a parser taking `count` bits and comparing them to `pattern`
<a href=#83 id=83 data-nosnippet>83</a></span><span class="kw">pub fn </span>tag&lt;I, O, C, E: ParseError&lt;(I, usize)&gt;&gt;(
<a href=#84 id=84 data-nosnippet>84</a> pattern: O,
<a href=#85 id=85 data-nosnippet>85</a> count: C,
<a href=#86 id=86 data-nosnippet>86</a>) -&gt; <span class="kw">impl </span>Fn((I, usize)) -&gt; IResult&lt;(I, usize), O, E&gt;
<a href=#87 id=87 data-nosnippet>87</a><span class="kw">where
<a href=#88 id=88 data-nosnippet>88</a> </span>I: Input&lt;Item = u8&gt; + Clone,
<a href=#89 id=89 data-nosnippet>89</a> C: ToUsize,
<a href=#90 id=90 data-nosnippet>90</a> O: From&lt;u8&gt; + AddAssign + Shl&lt;usize, Output = O&gt; + Shr&lt;usize, Output = O&gt; + PartialEq,
<a href=#91 id=91 data-nosnippet>91</a>{
<a href=#92 id=92 data-nosnippet>92</a> <span class="kw">let </span>count = count.to_usize();
<a href=#93 id=93 data-nosnippet>93</a> <span class="kw">move </span>|input: (I, usize)| {
<a href=#94 id=94 data-nosnippet>94</a> <span class="kw">let </span>inp = input.clone();
<a href=#95 id=95 data-nosnippet>95</a>
<a href=#96 id=96 data-nosnippet>96</a> take(count)(input).and_then(|(i, o)| {
<a href=#97 id=97 data-nosnippet>97</a> <span class="kw">if </span>pattern == o {
<a href=#98 id=98 data-nosnippet>98</a> <span class="prelude-val">Ok</span>((i, o))
<a href=#99 id=99 data-nosnippet>99</a> } <span class="kw">else </span>{
<a href=#100 id=100 data-nosnippet>100</a> <span class="prelude-val">Err</span>(Err::Error(<span class="macro">error_position!</span>(inp, ErrorKind::TagBits)))
<a href=#101 id=101 data-nosnippet>101</a> }
<a href=#102 id=102 data-nosnippet>102</a> })
<a href=#103 id=103 data-nosnippet>103</a> }
<a href=#104 id=104 data-nosnippet>104</a>}
<a href=#105 id=105 data-nosnippet>105</a>
<a href=#106 id=106 data-nosnippet>106</a><span class="doccomment">/// Parses one specific bit as a bool.
<a href=#107 id=107 data-nosnippet>107</a>///
<a href=#108 id=108 data-nosnippet>108</a>/// # Example
<a href=#109 id=109 data-nosnippet>109</a>/// ```rust
<a href=#110 id=110 data-nosnippet>110</a>/// # use nom::bits::complete::bool;
<a href=#111 id=111 data-nosnippet>111</a>/// # use nom::IResult;
<a href=#112 id=112 data-nosnippet>112</a>/// # use nom::error::{Error, ErrorKind};
<a href=#113 id=113 data-nosnippet>113</a>///
<a href=#114 id=114 data-nosnippet>114</a>/// fn parse(input: (&amp;[u8], usize)) -&gt; IResult&lt;(&amp;[u8], usize), bool&gt; {
<a href=#115 id=115 data-nosnippet>115</a>/// bool(input)
<a href=#116 id=116 data-nosnippet>116</a>/// }
<a href=#117 id=117 data-nosnippet>117</a>///
<a href=#118 id=118 data-nosnippet>118</a>/// assert_eq!(parse(([0b10000000].as_ref(), 0)), Ok((([0b10000000].as_ref(), 1), true)));
<a href=#119 id=119 data-nosnippet>119</a>/// assert_eq!(parse(([0b10000000].as_ref(), 1)), Ok((([0b10000000].as_ref(), 2), false)));
<a href=#120 id=120 data-nosnippet>120</a>/// ```
<a href=#121 id=121 data-nosnippet>121</a></span><span class="kw">pub fn </span>bool&lt;I, E: ParseError&lt;(I, usize)&gt;&gt;(input: (I, usize)) -&gt; IResult&lt;(I, usize), bool, E&gt;
<a href=#122 id=122 data-nosnippet>122</a><span class="kw">where
<a href=#123 id=123 data-nosnippet>123</a> </span>I: Input&lt;Item = u8&gt;,
<a href=#124 id=124 data-nosnippet>124</a>{
<a href=#125 id=125 data-nosnippet>125</a> <span class="kw">let </span>(res, bit): (<span class="kw">_</span>, u32) = take(<span class="number">1usize</span>)(input)<span class="question-mark">?</span>;
<a href=#126 id=126 data-nosnippet>126</a> <span class="prelude-val">Ok</span>((res, <span class="macro">bit !</span>= <span class="number">0</span>))
<a href=#127 id=127 data-nosnippet>127</a>}
<a href=#128 id=128 data-nosnippet>128</a>
<a href=#129 id=129 data-nosnippet>129</a><span class="attr">#[cfg(test)]
<a href=#130 id=130 data-nosnippet>130</a></span><span class="kw">mod </span>test {
<a href=#131 id=131 data-nosnippet>131</a> <span class="kw">use super</span>::<span class="kw-2">*</span>;
<a href=#132 id=132 data-nosnippet>132</a>
<a href=#133 id=133 data-nosnippet>133</a> <span class="attr">#[test]
<a href=#134 id=134 data-nosnippet>134</a> </span><span class="kw">fn </span>test_take_0() {
<a href=#135 id=135 data-nosnippet>135</a> <span class="kw">let </span>input = [<span class="number">0b00010010</span>].as_ref();
<a href=#136 id=136 data-nosnippet>136</a> <span class="kw">let </span>count = <span class="number">0usize</span>;
<a href=#137 id=137 data-nosnippet>137</a> <span class="macro">assert_eq!</span>(count, <span class="number">0usize</span>);
<a href=#138 id=138 data-nosnippet>138</a> <span class="kw">let </span>offset = <span class="number">0usize</span>;
<a href=#139 id=139 data-nosnippet>139</a>
<a href=#140 id=140 data-nosnippet>140</a> <span class="kw">let </span>result: <span class="kw">crate</span>::IResult&lt;(<span class="kw-2">&amp;</span>[u8], usize), usize&gt; = take(count)((input, offset));
<a href=#141 id=141 data-nosnippet>141</a>
<a href=#142 id=142 data-nosnippet>142</a> <span class="macro">assert_eq!</span>(result, <span class="prelude-val">Ok</span>(((input, offset), <span class="number">0</span>)));
<a href=#143 id=143 data-nosnippet>143</a> }
<a href=#144 id=144 data-nosnippet>144</a>
<a href=#145 id=145 data-nosnippet>145</a> <span class="attr">#[test]
<a href=#146 id=146 data-nosnippet>146</a> </span><span class="kw">fn </span>test_take_eof() {
<a href=#147 id=147 data-nosnippet>147</a> <span class="kw">let </span>input = [<span class="number">0b00010010</span>].as_ref();
<a href=#148 id=148 data-nosnippet>148</a>
<a href=#149 id=149 data-nosnippet>149</a> <span class="kw">let </span>result: <span class="kw">crate</span>::IResult&lt;(<span class="kw-2">&amp;</span>[u8], usize), usize&gt; = take(<span class="number">1usize</span>)((input, <span class="number">8</span>));
<a href=#150 id=150 data-nosnippet>150</a>
<a href=#151 id=151 data-nosnippet>151</a> <span class="macro">assert_eq!</span>(
<a href=#152 id=152 data-nosnippet>152</a> result,
<a href=#153 id=153 data-nosnippet>153</a> <span class="prelude-val">Err</span>(<span class="kw">crate</span>::Err::Error(<span class="kw">crate</span>::error::Error {
<a href=#154 id=154 data-nosnippet>154</a> input: (input, <span class="number">8</span>),
<a href=#155 id=155 data-nosnippet>155</a> code: ErrorKind::Eof
<a href=#156 id=156 data-nosnippet>156</a> }))
<a href=#157 id=157 data-nosnippet>157</a> )
<a href=#158 id=158 data-nosnippet>158</a> }
<a href=#159 id=159 data-nosnippet>159</a>
<a href=#160 id=160 data-nosnippet>160</a> <span class="attr">#[test]
<a href=#161 id=161 data-nosnippet>161</a> </span><span class="kw">fn </span>test_take_span_over_multiple_bytes() {
<a href=#162 id=162 data-nosnippet>162</a> <span class="kw">let </span>input = [<span class="number">0b00010010</span>, <span class="number">0b00110100</span>, <span class="number">0b11111111</span>, <span class="number">0b11111111</span>].as_ref();
<a href=#163 id=163 data-nosnippet>163</a>
<a href=#164 id=164 data-nosnippet>164</a> <span class="kw">let </span>result: <span class="kw">crate</span>::IResult&lt;(<span class="kw-2">&amp;</span>[u8], usize), usize&gt; = take(<span class="number">24usize</span>)((input, <span class="number">4</span>));
<a href=#165 id=165 data-nosnippet>165</a>
<a href=#166 id=166 data-nosnippet>166</a> <span class="macro">assert_eq!</span>(
<a href=#167 id=167 data-nosnippet>167</a> result,
<a href=#168 id=168 data-nosnippet>168</a> <span class="prelude-val">Ok</span>((([<span class="number">0b11111111</span>].as_ref(), <span class="number">4</span>), <span class="number">0b1000110100111111111111</span>))
<a href=#169 id=169 data-nosnippet>169</a> );
<a href=#170 id=170 data-nosnippet>170</a> }
<a href=#171 id=171 data-nosnippet>171</a>
<a href=#172 id=172 data-nosnippet>172</a> <span class="attr">#[test]
<a href=#173 id=173 data-nosnippet>173</a> </span><span class="kw">fn </span>test_bool_0() {
<a href=#174 id=174 data-nosnippet>174</a> <span class="kw">let </span>input = [<span class="number">0b10000000</span>].as_ref();
<a href=#175 id=175 data-nosnippet>175</a>
<a href=#176 id=176 data-nosnippet>176</a> <span class="kw">let </span>result: <span class="kw">crate</span>::IResult&lt;(<span class="kw-2">&amp;</span>[u8], usize), bool&gt; = bool((input, <span class="number">0</span>));
<a href=#177 id=177 data-nosnippet>177</a>
<a href=#178 id=178 data-nosnippet>178</a> <span class="macro">assert_eq!</span>(result, <span class="prelude-val">Ok</span>(((input, <span class="number">1</span>), <span class="bool-val">true</span>)));
<a href=#179 id=179 data-nosnippet>179</a> }
<a href=#180 id=180 data-nosnippet>180</a>
<a href=#181 id=181 data-nosnippet>181</a> <span class="attr">#[test]
<a href=#182 id=182 data-nosnippet>182</a> </span><span class="kw">fn </span>test_bool_eof() {
<a href=#183 id=183 data-nosnippet>183</a> <span class="kw">let </span>input = [<span class="number">0b10000000</span>].as_ref();
<a href=#184 id=184 data-nosnippet>184</a>
<a href=#185 id=185 data-nosnippet>185</a> <span class="kw">let </span>result: <span class="kw">crate</span>::IResult&lt;(<span class="kw-2">&amp;</span>[u8], usize), bool&gt; = bool((input, <span class="number">8</span>));
<a href=#186 id=186 data-nosnippet>186</a>
<a href=#187 id=187 data-nosnippet>187</a> <span class="macro">assert_eq!</span>(
<a href=#188 id=188 data-nosnippet>188</a> result,
<a href=#189 id=189 data-nosnippet>189</a> <span class="prelude-val">Err</span>(<span class="kw">crate</span>::Err::Error(<span class="kw">crate</span>::error::Error {
<a href=#190 id=190 data-nosnippet>190</a> input: (input, <span class="number">8</span>),
<a href=#191 id=191 data-nosnippet>191</a> code: ErrorKind::Eof
<a href=#192 id=192 data-nosnippet>192</a> }))
<a href=#193 id=193 data-nosnippet>193</a> );
<a href=#194 id=194 data-nosnippet>194</a> }
<a href=#195 id=195 data-nosnippet>195</a>}
</code></pre></div></section></main></body></html>
+175
View File
@@ -0,0 +1,175 @@
<!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 of the Rust file `/home/newkirk/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/nom-8.0.0/src/bits/mod.rs`."><title>mod.rs - source</title><script>if(window.location.protocol!=="file:")document.head.insertAdjacentHTML("beforeend","SourceSerif4-Regular-6b053e98.ttf.woff2,FiraSans-Italic-81dc35de.woff2,FiraSans-Regular-0fe48ade.woff2,FiraSans-MediumItalic-ccf7e434.woff2,FiraSans-Medium-e1aa3f0a.woff2,SourceCodePro-Regular-8badfe75.ttf.woff2,SourceCodePro-Semibold-aa29a496.ttf.woff2".split(",").map(f=>`<link rel="preload" as="font" type="font/woff2"href="../../../static.files/${f}">`).join(""))</script><link rel="stylesheet" href="../../../static.files/normalize-9960930a.css"><link rel="stylesheet" href="../../../static.files/rustdoc-ca0dd0c4.css"><meta name="rustdoc-vars" data-root-path="../../../" data-static-root-path="../../../static.files/" data-current-crate="nom" data-themes="" data-resource-suffix="" data-rustdoc-version="1.93.1 (01f6ddf75 2026-02-11) (Arch Linux rust 1:1.93.1-1)" data-channel="1.93.1" data-search-js="search-9e2438ea.js" data-stringdex-js="stringdex-a3946164.js" data-settings-js="settings-c38705f0.js" ><script src="../../../static.files/storage-e2aeef58.js"></script><script defer src="../../../static.files/src-script-813739b1.js"></script><script defer src="../../../src-files.js"></script><script defer src="../../../static.files/main-a410ff4d.js"></script><noscript><link rel="stylesheet" href="../../../static.files/noscript-263c88ec.css"></noscript><link rel="alternate icon" type="image/png" href="../../../static.files/favicon-32x32-eab170b8.png"><link rel="icon" type="image/svg+xml" href="../../../static.files/favicon-044be391.svg"></head><body class="rustdoc src"><!--[if lte IE 11]><div class="warning">This old browser is unsupported and will most likely display funky things.</div><![endif]--><nav class="sidebar"><div class="src-sidebar-title"><h2>Files</h2></div></nav><div class="sidebar-resizer" title="Drag to resize sidebar"></div><main><section id="main-content" class="content"><div class="main-heading"><h1><div class="sub-heading">nom/bits/</div>mod.rs</h1><rustdoc-toolbar></rustdoc-toolbar></div><div class="example-wrap digits-3"><pre class="rust"><code><a href=#1 id=1 data-nosnippet>1</a><span class="doccomment">//! Bit level parsers
<a href=#2 id=2 data-nosnippet>2</a>//!
<a href=#3 id=3 data-nosnippet>3</a>
<a href=#4 id=4 data-nosnippet>4</a></span><span class="kw">pub mod </span>complete;
<a href=#5 id=5 data-nosnippet>5</a><span class="kw">pub mod </span>streaming;
<a href=#6 id=6 data-nosnippet>6</a>
<a href=#7 id=7 data-nosnippet>7</a><span class="kw">use </span><span class="kw">crate</span>::error::{ErrorKind, ParseError};
<a href=#8 id=8 data-nosnippet>8</a><span class="kw">use </span><span class="kw">crate</span>::internal::{<span class="prelude-val">Err</span>, IResult, Needed, Parser};
<a href=#9 id=9 data-nosnippet>9</a><span class="kw">use </span><span class="kw">crate</span>::traits::ErrorConvert;
<a href=#10 id=10 data-nosnippet>10</a><span class="kw">use </span><span class="kw">crate</span>::Input;
<a href=#11 id=11 data-nosnippet>11</a>
<a href=#12 id=12 data-nosnippet>12</a><span class="doccomment">/// Converts a byte-level input to a bit-level input, for consumption by a parser that uses bits.
<a href=#13 id=13 data-nosnippet>13</a>///
<a href=#14 id=14 data-nosnippet>14</a>/// Afterwards, the input is converted back to a byte-level parser, with any remaining bits thrown
<a href=#15 id=15 data-nosnippet>15</a>/// away.
<a href=#16 id=16 data-nosnippet>16</a>///
<a href=#17 id=17 data-nosnippet>17</a>/// # Example
<a href=#18 id=18 data-nosnippet>18</a>/// ```
<a href=#19 id=19 data-nosnippet>19</a>/// use nom::bits::{bits, streaming::take};
<a href=#20 id=20 data-nosnippet>20</a>/// use nom::error::Error;
<a href=#21 id=21 data-nosnippet>21</a>/// use nom::IResult;
<a href=#22 id=22 data-nosnippet>22</a>///
<a href=#23 id=23 data-nosnippet>23</a>/// fn parse(input: &amp;[u8]) -&gt; IResult&lt;&amp;[u8], (u8, u8)&gt; {
<a href=#24 id=24 data-nosnippet>24</a>/// bits::&lt;_, _, Error&lt;(&amp;[u8], usize)&gt;, _, _&gt;((take(4usize), take(8usize)))(input)
<a href=#25 id=25 data-nosnippet>25</a>/// }
<a href=#26 id=26 data-nosnippet>26</a>///
<a href=#27 id=27 data-nosnippet>27</a>/// let input = &amp;[0x12, 0x34, 0xff, 0xff];
<a href=#28 id=28 data-nosnippet>28</a>///
<a href=#29 id=29 data-nosnippet>29</a>/// let output = parse(input).expect("We take 1.5 bytes and the input is longer than 2 bytes");
<a href=#30 id=30 data-nosnippet>30</a>///
<a href=#31 id=31 data-nosnippet>31</a>/// // The first byte is consumed, the second byte is partially consumed and dropped.
<a href=#32 id=32 data-nosnippet>32</a>/// let remaining = output.0;
<a href=#33 id=33 data-nosnippet>33</a>/// assert_eq!(remaining, [0xff, 0xff]);
<a href=#34 id=34 data-nosnippet>34</a>///
<a href=#35 id=35 data-nosnippet>35</a>/// let parsed = output.1;
<a href=#36 id=36 data-nosnippet>36</a>/// assert_eq!(parsed.0, 0x01);
<a href=#37 id=37 data-nosnippet>37</a>/// assert_eq!(parsed.1, 0x23);
<a href=#38 id=38 data-nosnippet>38</a>/// ```
<a href=#39 id=39 data-nosnippet>39</a></span><span class="kw">pub fn </span>bits&lt;I, O, E1, E2, P&gt;(<span class="kw-2">mut </span>parser: P) -&gt; <span class="kw">impl </span>FnMut(I) -&gt; IResult&lt;I, O, E2&gt;
<a href=#40 id=40 data-nosnippet>40</a><span class="kw">where
<a href=#41 id=41 data-nosnippet>41</a> </span>E1: ParseError&lt;(I, usize)&gt; + ErrorConvert&lt;E2&gt;,
<a href=#42 id=42 data-nosnippet>42</a> E2: ParseError&lt;I&gt;,
<a href=#43 id=43 data-nosnippet>43</a> I: Input,
<a href=#44 id=44 data-nosnippet>44</a> P: Parser&lt;(I, usize), Output = O, Error = E1&gt;,
<a href=#45 id=45 data-nosnippet>45</a>{
<a href=#46 id=46 data-nosnippet>46</a> <span class="kw">move </span>|input: I| <span class="kw">match </span>parser.parse((input, <span class="number">0</span>)) {
<a href=#47 id=47 data-nosnippet>47</a> <span class="prelude-val">Ok</span>(((rest, offset), result)) =&gt; {
<a href=#48 id=48 data-nosnippet>48</a> <span class="comment">// If the next byte has been partially read, it will be sliced away as well.
<a href=#49 id=49 data-nosnippet>49</a> // The parser functions might already slice away all fully read bytes.
<a href=#50 id=50 data-nosnippet>50</a> // That's why `offset / 8` isn't necessarily needed at all times.
<a href=#51 id=51 data-nosnippet>51</a> </span><span class="kw">let </span>remaining_bytes_index = offset / <span class="number">8 </span>+ <span class="kw">if </span>offset % <span class="number">8 </span>== <span class="number">0 </span>{ <span class="number">0 </span>} <span class="kw">else </span>{ <span class="number">1 </span>};
<a href=#52 id=52 data-nosnippet>52</a> <span class="prelude-val">Ok</span>((rest.take_from(remaining_bytes_index), result))
<a href=#53 id=53 data-nosnippet>53</a> }
<a href=#54 id=54 data-nosnippet>54</a> <span class="prelude-val">Err</span>(Err::Incomplete(n)) =&gt; <span class="prelude-val">Err</span>(Err::Incomplete(n.map(|u| u.get() / <span class="number">8 </span>+ <span class="number">1</span>))),
<a href=#55 id=55 data-nosnippet>55</a> <span class="prelude-val">Err</span>(Err::Error(e)) =&gt; <span class="prelude-val">Err</span>(Err::Error(e.convert())),
<a href=#56 id=56 data-nosnippet>56</a> <span class="prelude-val">Err</span>(Err::Failure(e)) =&gt; <span class="prelude-val">Err</span>(Err::Failure(e.convert())),
<a href=#57 id=57 data-nosnippet>57</a> }
<a href=#58 id=58 data-nosnippet>58</a>}
<a href=#59 id=59 data-nosnippet>59</a>
<a href=#60 id=60 data-nosnippet>60</a><span class="doccomment">/// Counterpart to `bits`, `bytes` transforms its bit stream input into a byte slice for the underlying
<a href=#61 id=61 data-nosnippet>61</a>/// parser, allowing byte-slice parsers to work on bit streams.
<a href=#62 id=62 data-nosnippet>62</a>///
<a href=#63 id=63 data-nosnippet>63</a>/// A partial byte remaining in the input will be ignored and the given parser will start parsing
<a href=#64 id=64 data-nosnippet>64</a>/// at the next full byte.
<a href=#65 id=65 data-nosnippet>65</a>///
<a href=#66 id=66 data-nosnippet>66</a>/// ```
<a href=#67 id=67 data-nosnippet>67</a>/// use nom::bits::{bits, bytes, streaming::take};
<a href=#68 id=68 data-nosnippet>68</a>/// use nom::combinator::rest;
<a href=#69 id=69 data-nosnippet>69</a>/// use nom::error::Error;
<a href=#70 id=70 data-nosnippet>70</a>/// use nom::IResult;
<a href=#71 id=71 data-nosnippet>71</a>///
<a href=#72 id=72 data-nosnippet>72</a>/// fn parse(input: &amp;[u8]) -&gt; IResult&lt;&amp;[u8], (u8, u8, &amp;[u8])&gt; {
<a href=#73 id=73 data-nosnippet>73</a>/// bits::&lt;_, _, Error&lt;(&amp;[u8], usize)&gt;, _, _&gt;((
<a href=#74 id=74 data-nosnippet>74</a>/// take(4usize),
<a href=#75 id=75 data-nosnippet>75</a>/// take(8usize),
<a href=#76 id=76 data-nosnippet>76</a>/// bytes::&lt;_, _, Error&lt;&amp;[u8]&gt;, _, _&gt;(rest)
<a href=#77 id=77 data-nosnippet>77</a>/// ))(input)
<a href=#78 id=78 data-nosnippet>78</a>/// }
<a href=#79 id=79 data-nosnippet>79</a>///
<a href=#80 id=80 data-nosnippet>80</a>/// let input = &amp;[0x12, 0x34, 0xff, 0xff];
<a href=#81 id=81 data-nosnippet>81</a>///
<a href=#82 id=82 data-nosnippet>82</a>/// assert_eq!(parse( input ), Ok(( &amp;[][..], (0x01, 0x23, &amp;[0xff, 0xff][..]) )));
<a href=#83 id=83 data-nosnippet>83</a>/// ```
<a href=#84 id=84 data-nosnippet>84</a></span><span class="kw">pub fn </span>bytes&lt;I, O, E1, E2, P&gt;(<span class="kw-2">mut </span>parser: P) -&gt; <span class="kw">impl </span>FnMut((I, usize)) -&gt; IResult&lt;(I, usize), O, E2&gt;
<a href=#85 id=85 data-nosnippet>85</a><span class="kw">where
<a href=#86 id=86 data-nosnippet>86</a> </span>E1: ParseError&lt;I&gt; + ErrorConvert&lt;E2&gt;,
<a href=#87 id=87 data-nosnippet>87</a> E2: ParseError&lt;(I, usize)&gt;,
<a href=#88 id=88 data-nosnippet>88</a> I: Input + Clone,
<a href=#89 id=89 data-nosnippet>89</a> P: Parser&lt;I, Output = O, Error = E1&gt;,
<a href=#90 id=90 data-nosnippet>90</a>{
<a href=#91 id=91 data-nosnippet>91</a> <span class="kw">move </span>|(input, offset): (I, usize)| {
<a href=#92 id=92 data-nosnippet>92</a> <span class="kw">let </span>inner = <span class="kw">if </span>offset % <span class="number">8 </span>!= <span class="number">0 </span>{
<a href=#93 id=93 data-nosnippet>93</a> input.take_from(<span class="number">1 </span>+ offset / <span class="number">8</span>)
<a href=#94 id=94 data-nosnippet>94</a> } <span class="kw">else </span>{
<a href=#95 id=95 data-nosnippet>95</a> input.take_from(offset / <span class="number">8</span>)
<a href=#96 id=96 data-nosnippet>96</a> };
<a href=#97 id=97 data-nosnippet>97</a> <span class="kw">let </span>i = (input, offset);
<a href=#98 id=98 data-nosnippet>98</a> <span class="kw">match </span>parser.parse(inner) {
<a href=#99 id=99 data-nosnippet>99</a> <span class="prelude-val">Ok</span>((rest, res)) =&gt; <span class="prelude-val">Ok</span>(((rest, <span class="number">0</span>), res)),
<a href=#100 id=100 data-nosnippet>100</a> <span class="prelude-val">Err</span>(Err::Incomplete(Needed::Unknown)) =&gt; <span class="prelude-val">Err</span>(Err::Incomplete(Needed::Unknown)),
<a href=#101 id=101 data-nosnippet>101</a> <span class="prelude-val">Err</span>(Err::Incomplete(Needed::Size(sz))) =&gt; <span class="prelude-val">Err</span>(<span class="kw">match </span>sz.get().checked_mul(<span class="number">8</span>) {
<a href=#102 id=102 data-nosnippet>102</a> <span class="prelude-val">Some</span>(v) =&gt; Err::Incomplete(Needed::new(v)),
<a href=#103 id=103 data-nosnippet>103</a> <span class="prelude-val">None </span>=&gt; Err::Failure(E2::from_error_kind(i, ErrorKind::TooLarge)),
<a href=#104 id=104 data-nosnippet>104</a> }),
<a href=#105 id=105 data-nosnippet>105</a> <span class="prelude-val">Err</span>(Err::Error(e)) =&gt; <span class="prelude-val">Err</span>(Err::Error(e.convert())),
<a href=#106 id=106 data-nosnippet>106</a> <span class="prelude-val">Err</span>(Err::Failure(e)) =&gt; <span class="prelude-val">Err</span>(Err::Failure(e.convert())),
<a href=#107 id=107 data-nosnippet>107</a> }
<a href=#108 id=108 data-nosnippet>108</a> }
<a href=#109 id=109 data-nosnippet>109</a>}
<a href=#110 id=110 data-nosnippet>110</a>
<a href=#111 id=111 data-nosnippet>111</a><span class="attr">#[cfg(test)]
<a href=#112 id=112 data-nosnippet>112</a></span><span class="kw">mod </span>test {
<a href=#113 id=113 data-nosnippet>113</a> <span class="kw">use super</span>::<span class="kw-2">*</span>;
<a href=#114 id=114 data-nosnippet>114</a> <span class="kw">use </span><span class="kw">crate</span>::bits::streaming::take;
<a href=#115 id=115 data-nosnippet>115</a> <span class="kw">use </span><span class="kw">crate</span>::error::Error;
<a href=#116 id=116 data-nosnippet>116</a>
<a href=#117 id=117 data-nosnippet>117</a> <span class="attr">#[test]
<a href=#118 id=118 data-nosnippet>118</a> </span><span class="doccomment">/// Take the `bits` function and assert that remaining bytes are correctly returned, if the
<a href=#119 id=119 data-nosnippet>119</a> /// previous bytes are fully consumed
<a href=#120 id=120 data-nosnippet>120</a> </span><span class="kw">fn </span>test_complete_byte_consumption_bits() {
<a href=#121 id=121 data-nosnippet>121</a> <span class="kw">let </span>input = <span class="kw-2">&amp;</span>[<span class="number">0x12</span>, <span class="number">0x34</span>, <span class="number">0x56</span>, <span class="number">0x78</span>];
<a href=#122 id=122 data-nosnippet>122</a>
<a href=#123 id=123 data-nosnippet>123</a> <span class="comment">// Take 3 bit slices with sizes [4, 8, 4].
<a href=#124 id=124 data-nosnippet>124</a> </span><span class="kw">let </span>result: IResult&lt;<span class="kw-2">&amp;</span>[u8], (u8, u8, u8)&gt; =
<a href=#125 id=125 data-nosnippet>125</a> bits::&lt;<span class="kw">_</span>, <span class="kw">_</span>, Error&lt;(<span class="kw-2">&amp;</span>[u8], usize)&gt;, <span class="kw">_</span>, <span class="kw">_</span>&gt;((take(<span class="number">4usize</span>), take(<span class="number">8usize</span>), take(<span class="number">4usize</span>)))(input);
<a href=#126 id=126 data-nosnippet>126</a>
<a href=#127 id=127 data-nosnippet>127</a> <span class="kw">let </span>output = result.expect(<span class="string">"We take 2 bytes and the input is longer than 2 bytes"</span>);
<a href=#128 id=128 data-nosnippet>128</a>
<a href=#129 id=129 data-nosnippet>129</a> <span class="kw">let </span>remaining = output.<span class="number">0</span>;
<a href=#130 id=130 data-nosnippet>130</a> <span class="macro">assert_eq!</span>(remaining, [<span class="number">0x56</span>, <span class="number">0x78</span>]);
<a href=#131 id=131 data-nosnippet>131</a>
<a href=#132 id=132 data-nosnippet>132</a> <span class="kw">let </span>parsed = output.<span class="number">1</span>;
<a href=#133 id=133 data-nosnippet>133</a> <span class="macro">assert_eq!</span>(parsed.<span class="number">0</span>, <span class="number">0x01</span>);
<a href=#134 id=134 data-nosnippet>134</a> <span class="macro">assert_eq!</span>(parsed.<span class="number">1</span>, <span class="number">0x23</span>);
<a href=#135 id=135 data-nosnippet>135</a> <span class="macro">assert_eq!</span>(parsed.<span class="number">2</span>, <span class="number">0x04</span>);
<a href=#136 id=136 data-nosnippet>136</a> }
<a href=#137 id=137 data-nosnippet>137</a>
<a href=#138 id=138 data-nosnippet>138</a> <span class="attr">#[test]
<a href=#139 id=139 data-nosnippet>139</a> </span><span class="doccomment">/// Take the `bits` function and assert that remaining bytes are correctly returned, if the
<a href=#140 id=140 data-nosnippet>140</a> /// previous bytes are NOT fully consumed. Partially consumed bytes are supposed to be dropped.
<a href=#141 id=141 data-nosnippet>141</a> /// I.e. if we consume 1.5 bytes of 4 bytes, 2 bytes will be returned, bits 13-16 will be
<a href=#142 id=142 data-nosnippet>142</a> /// dropped.
<a href=#143 id=143 data-nosnippet>143</a> </span><span class="kw">fn </span>test_partial_byte_consumption_bits() {
<a href=#144 id=144 data-nosnippet>144</a> <span class="kw">let </span>input = <span class="kw-2">&amp;</span>[<span class="number">0x12</span>, <span class="number">0x34</span>, <span class="number">0x56</span>, <span class="number">0x78</span>];
<a href=#145 id=145 data-nosnippet>145</a>
<a href=#146 id=146 data-nosnippet>146</a> <span class="comment">// Take bit slices with sizes [4, 8].
<a href=#147 id=147 data-nosnippet>147</a> </span><span class="kw">let </span>result: IResult&lt;<span class="kw-2">&amp;</span>[u8], (u8, u8)&gt; =
<a href=#148 id=148 data-nosnippet>148</a> bits::&lt;<span class="kw">_</span>, <span class="kw">_</span>, Error&lt;(<span class="kw-2">&amp;</span>[u8], usize)&gt;, <span class="kw">_</span>, <span class="kw">_</span>&gt;((take(<span class="number">4usize</span>), take(<span class="number">8usize</span>)))(input);
<a href=#149 id=149 data-nosnippet>149</a>
<a href=#150 id=150 data-nosnippet>150</a> <span class="kw">let </span>output = result.expect(<span class="string">"We take 1.5 bytes and the input is longer than 2 bytes"</span>);
<a href=#151 id=151 data-nosnippet>151</a>
<a href=#152 id=152 data-nosnippet>152</a> <span class="kw">let </span>remaining = output.<span class="number">0</span>;
<a href=#153 id=153 data-nosnippet>153</a> <span class="macro">assert_eq!</span>(remaining, [<span class="number">0x56</span>, <span class="number">0x78</span>]);
<a href=#154 id=154 data-nosnippet>154</a>
<a href=#155 id=155 data-nosnippet>155</a> <span class="kw">let </span>parsed = output.<span class="number">1</span>;
<a href=#156 id=156 data-nosnippet>156</a> <span class="macro">assert_eq!</span>(parsed.<span class="number">0</span>, <span class="number">0x01</span>);
<a href=#157 id=157 data-nosnippet>157</a> <span class="macro">assert_eq!</span>(parsed.<span class="number">1</span>, <span class="number">0x23</span>);
<a href=#158 id=158 data-nosnippet>158</a> }
<a href=#159 id=159 data-nosnippet>159</a>
<a href=#160 id=160 data-nosnippet>160</a> <span class="attr">#[test]
<a href=#161 id=161 data-nosnippet>161</a> #[cfg(feature = <span class="string">"std"</span>)]
<a href=#162 id=162 data-nosnippet>162</a> </span><span class="doccomment">/// Ensure that in Incomplete error is thrown, if too few bytes are passed for a given parser.
<a href=#163 id=163 data-nosnippet>163</a> </span><span class="kw">fn </span>test_incomplete_bits() {
<a href=#164 id=164 data-nosnippet>164</a> <span class="kw">let </span>input = <span class="kw-2">&amp;</span>[<span class="number">0x12</span>];
<a href=#165 id=165 data-nosnippet>165</a>
<a href=#166 id=166 data-nosnippet>166</a> <span class="comment">// Take bit slices with sizes [4, 8].
<a href=#167 id=167 data-nosnippet>167</a> </span><span class="kw">let </span>result: IResult&lt;<span class="kw-2">&amp;</span>[u8], (u8, u8)&gt; =
<a href=#168 id=168 data-nosnippet>168</a> bits::&lt;<span class="kw">_</span>, <span class="kw">_</span>, Error&lt;(<span class="kw-2">&amp;</span>[u8], usize)&gt;, <span class="kw">_</span>, <span class="kw">_</span>&gt;((take(<span class="number">4usize</span>), take(<span class="number">8usize</span>)))(input);
<a href=#169 id=169 data-nosnippet>169</a>
<a href=#170 id=170 data-nosnippet>170</a> <span class="macro">assert!</span>(result.is_err());
<a href=#171 id=171 data-nosnippet>171</a> <span class="kw">let </span>error = result.err().unwrap();
<a href=#172 id=172 data-nosnippet>172</a> <span class="macro">assert_eq!</span>(<span class="string">"Parsing requires 2 bytes/chars"</span>, error.to_string());
<a href=#173 id=173 data-nosnippet>173</a> }
<a href=#174 id=174 data-nosnippet>174</a>}
</code></pre></div></section></main></body></html>
+171
View File
@@ -0,0 +1,171 @@
<!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 of the Rust file `/home/newkirk/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/nom-8.0.0/src/bits/streaming.rs`."><title>streaming.rs - source</title><script>if(window.location.protocol!=="file:")document.head.insertAdjacentHTML("beforeend","SourceSerif4-Regular-6b053e98.ttf.woff2,FiraSans-Italic-81dc35de.woff2,FiraSans-Regular-0fe48ade.woff2,FiraSans-MediumItalic-ccf7e434.woff2,FiraSans-Medium-e1aa3f0a.woff2,SourceCodePro-Regular-8badfe75.ttf.woff2,SourceCodePro-Semibold-aa29a496.ttf.woff2".split(",").map(f=>`<link rel="preload" as="font" type="font/woff2"href="../../../static.files/${f}">`).join(""))</script><link rel="stylesheet" href="../../../static.files/normalize-9960930a.css"><link rel="stylesheet" href="../../../static.files/rustdoc-ca0dd0c4.css"><meta name="rustdoc-vars" data-root-path="../../../" data-static-root-path="../../../static.files/" data-current-crate="nom" data-themes="" data-resource-suffix="" data-rustdoc-version="1.93.1 (01f6ddf75 2026-02-11) (Arch Linux rust 1:1.93.1-1)" data-channel="1.93.1" data-search-js="search-9e2438ea.js" data-stringdex-js="stringdex-a3946164.js" data-settings-js="settings-c38705f0.js" ><script src="../../../static.files/storage-e2aeef58.js"></script><script defer src="../../../static.files/src-script-813739b1.js"></script><script defer src="../../../src-files.js"></script><script defer src="../../../static.files/main-a410ff4d.js"></script><noscript><link rel="stylesheet" href="../../../static.files/noscript-263c88ec.css"></noscript><link rel="alternate icon" type="image/png" href="../../../static.files/favicon-32x32-eab170b8.png"><link rel="icon" type="image/svg+xml" href="../../../static.files/favicon-044be391.svg"></head><body class="rustdoc src"><!--[if lte IE 11]><div class="warning">This old browser is unsupported and will most likely display funky things.</div><![endif]--><nav class="sidebar"><div class="src-sidebar-title"><h2>Files</h2></div></nav><div class="sidebar-resizer" title="Drag to resize sidebar"></div><main><section id="main-content" class="content"><div class="main-heading"><h1><div class="sub-heading">nom/bits/</div>streaming.rs</h1><rustdoc-toolbar></rustdoc-toolbar></div><div class="example-wrap digits-3"><pre class="rust"><code><a href=#1 id=1 data-nosnippet>1</a><span class="doccomment">//! Bit level parsers
<a href=#2 id=2 data-nosnippet>2</a>//!
<a href=#3 id=3 data-nosnippet>3</a>
<a href=#4 id=4 data-nosnippet>4</a></span><span class="kw">use </span><span class="kw">crate</span>::error::{ErrorKind, ParseError};
<a href=#5 id=5 data-nosnippet>5</a><span class="kw">use </span><span class="kw">crate</span>::internal::{<span class="prelude-val">Err</span>, IResult, Needed};
<a href=#6 id=6 data-nosnippet>6</a><span class="kw">use </span><span class="kw">crate</span>::lib::std::ops::{AddAssign, Div, Shl, Shr};
<a href=#7 id=7 data-nosnippet>7</a><span class="kw">use </span><span class="kw">crate</span>::traits::{Input, ToUsize};
<a href=#8 id=8 data-nosnippet>8</a>
<a href=#9 id=9 data-nosnippet>9</a><span class="doccomment">/// Generates a parser taking `count` bits
<a href=#10 id=10 data-nosnippet>10</a></span><span class="kw">pub fn </span>take&lt;I, O, C, E: ParseError&lt;(I, usize)&gt;&gt;(
<a href=#11 id=11 data-nosnippet>11</a> count: C,
<a href=#12 id=12 data-nosnippet>12</a>) -&gt; <span class="kw">impl </span>Fn((I, usize)) -&gt; IResult&lt;(I, usize), O, E&gt;
<a href=#13 id=13 data-nosnippet>13</a><span class="kw">where
<a href=#14 id=14 data-nosnippet>14</a> </span>I: Input&lt;Item = u8&gt;,
<a href=#15 id=15 data-nosnippet>15</a> C: ToUsize,
<a href=#16 id=16 data-nosnippet>16</a> O: From&lt;u8&gt; + AddAssign + Shl&lt;usize, Output = O&gt; + Shr&lt;usize, Output = O&gt;,
<a href=#17 id=17 data-nosnippet>17</a>{
<a href=#18 id=18 data-nosnippet>18</a> <span class="kw">let </span>count = count.to_usize();
<a href=#19 id=19 data-nosnippet>19</a> <span class="kw">move </span>|(input, bit_offset): (I, usize)| {
<a href=#20 id=20 data-nosnippet>20</a> <span class="kw">if </span>count == <span class="number">0 </span>{
<a href=#21 id=21 data-nosnippet>21</a> <span class="prelude-val">Ok</span>(((input, bit_offset), <span class="number">0u8</span>.into()))
<a href=#22 id=22 data-nosnippet>22</a> } <span class="kw">else </span>{
<a href=#23 id=23 data-nosnippet>23</a> <span class="kw">let </span>cnt = (count + bit_offset).div(<span class="number">8</span>);
<a href=#24 id=24 data-nosnippet>24</a> <span class="kw">if </span>input.input_len() * <span class="number">8 </span>&lt; count + bit_offset {
<a href=#25 id=25 data-nosnippet>25</a> <span class="prelude-val">Err</span>(Err::Incomplete(Needed::new(count)))
<a href=#26 id=26 data-nosnippet>26</a> } <span class="kw">else </span>{
<a href=#27 id=27 data-nosnippet>27</a> <span class="kw">let </span><span class="kw-2">mut </span>acc: O = <span class="number">0_u8</span>.into();
<a href=#28 id=28 data-nosnippet>28</a> <span class="kw">let </span><span class="kw-2">mut </span>offset: usize = bit_offset;
<a href=#29 id=29 data-nosnippet>29</a> <span class="kw">let </span><span class="kw-2">mut </span>remaining: usize = count;
<a href=#30 id=30 data-nosnippet>30</a> <span class="kw">let </span><span class="kw-2">mut </span>end_offset: usize = <span class="number">0</span>;
<a href=#31 id=31 data-nosnippet>31</a>
<a href=#32 id=32 data-nosnippet>32</a> <span class="kw">for </span>byte <span class="kw">in </span>input.iter_elements().take(cnt + <span class="number">1</span>) {
<a href=#33 id=33 data-nosnippet>33</a> <span class="kw">if </span>remaining == <span class="number">0 </span>{
<a href=#34 id=34 data-nosnippet>34</a> <span class="kw">break</span>;
<a href=#35 id=35 data-nosnippet>35</a> }
<a href=#36 id=36 data-nosnippet>36</a> <span class="kw">let </span>val: O = <span class="kw">if </span>offset == <span class="number">0 </span>{
<a href=#37 id=37 data-nosnippet>37</a> byte.into()
<a href=#38 id=38 data-nosnippet>38</a> } <span class="kw">else </span>{
<a href=#39 id=39 data-nosnippet>39</a> ((byte &lt;&lt; offset) &gt;&gt; offset).into()
<a href=#40 id=40 data-nosnippet>40</a> };
<a href=#41 id=41 data-nosnippet>41</a>
<a href=#42 id=42 data-nosnippet>42</a> <span class="kw">if </span>remaining &lt; <span class="number">8 </span>- offset {
<a href=#43 id=43 data-nosnippet>43</a> acc += val &gt;&gt; (<span class="number">8 </span>- offset - remaining);
<a href=#44 id=44 data-nosnippet>44</a> end_offset = remaining + offset;
<a href=#45 id=45 data-nosnippet>45</a> <span class="kw">break</span>;
<a href=#46 id=46 data-nosnippet>46</a> } <span class="kw">else </span>{
<a href=#47 id=47 data-nosnippet>47</a> acc += val &lt;&lt; (remaining - (<span class="number">8 </span>- offset));
<a href=#48 id=48 data-nosnippet>48</a> remaining -= <span class="number">8 </span>- offset;
<a href=#49 id=49 data-nosnippet>49</a> offset = <span class="number">0</span>;
<a href=#50 id=50 data-nosnippet>50</a> }
<a href=#51 id=51 data-nosnippet>51</a> }
<a href=#52 id=52 data-nosnippet>52</a> <span class="prelude-val">Ok</span>(((input.take_from(cnt), end_offset), acc))
<a href=#53 id=53 data-nosnippet>53</a> }
<a href=#54 id=54 data-nosnippet>54</a> }
<a href=#55 id=55 data-nosnippet>55</a> }
<a href=#56 id=56 data-nosnippet>56</a>}
<a href=#57 id=57 data-nosnippet>57</a>
<a href=#58 id=58 data-nosnippet>58</a><span class="doccomment">/// Generates a parser taking `count` bits and comparing them to `pattern`
<a href=#59 id=59 data-nosnippet>59</a></span><span class="kw">pub fn </span>tag&lt;I, O, C, E: ParseError&lt;(I, usize)&gt;&gt;(
<a href=#60 id=60 data-nosnippet>60</a> pattern: O,
<a href=#61 id=61 data-nosnippet>61</a> count: C,
<a href=#62 id=62 data-nosnippet>62</a>) -&gt; <span class="kw">impl </span>Fn((I, usize)) -&gt; IResult&lt;(I, usize), O, E&gt;
<a href=#63 id=63 data-nosnippet>63</a><span class="kw">where
<a href=#64 id=64 data-nosnippet>64</a> </span>I: Input&lt;Item = u8&gt; + Clone,
<a href=#65 id=65 data-nosnippet>65</a> C: ToUsize,
<a href=#66 id=66 data-nosnippet>66</a> O: From&lt;u8&gt; + AddAssign + Shl&lt;usize, Output = O&gt; + Shr&lt;usize, Output = O&gt; + PartialEq,
<a href=#67 id=67 data-nosnippet>67</a>{
<a href=#68 id=68 data-nosnippet>68</a> <span class="kw">let </span>count = count.to_usize();
<a href=#69 id=69 data-nosnippet>69</a> <span class="kw">move </span>|input: (I, usize)| {
<a href=#70 id=70 data-nosnippet>70</a> <span class="kw">let </span>inp = input.clone();
<a href=#71 id=71 data-nosnippet>71</a>
<a href=#72 id=72 data-nosnippet>72</a> take(count)(input).and_then(|(i, o)| {
<a href=#73 id=73 data-nosnippet>73</a> <span class="kw">if </span>pattern == o {
<a href=#74 id=74 data-nosnippet>74</a> <span class="prelude-val">Ok</span>((i, o))
<a href=#75 id=75 data-nosnippet>75</a> } <span class="kw">else </span>{
<a href=#76 id=76 data-nosnippet>76</a> <span class="prelude-val">Err</span>(Err::Error(<span class="macro">error_position!</span>(inp, ErrorKind::TagBits)))
<a href=#77 id=77 data-nosnippet>77</a> }
<a href=#78 id=78 data-nosnippet>78</a> })
<a href=#79 id=79 data-nosnippet>79</a> }
<a href=#80 id=80 data-nosnippet>80</a>}
<a href=#81 id=81 data-nosnippet>81</a>
<a href=#82 id=82 data-nosnippet>82</a><span class="doccomment">/// Parses one specific bit as a bool.
<a href=#83 id=83 data-nosnippet>83</a>///
<a href=#84 id=84 data-nosnippet>84</a>/// # Example
<a href=#85 id=85 data-nosnippet>85</a>/// ```rust
<a href=#86 id=86 data-nosnippet>86</a>/// # use nom::bits::complete::bool;
<a href=#87 id=87 data-nosnippet>87</a>/// # use nom::IResult;
<a href=#88 id=88 data-nosnippet>88</a>/// # use nom::error::{Error, ErrorKind};
<a href=#89 id=89 data-nosnippet>89</a>///
<a href=#90 id=90 data-nosnippet>90</a>/// fn parse(input: (&amp;[u8], usize)) -&gt; IResult&lt;(&amp;[u8], usize), bool&gt; {
<a href=#91 id=91 data-nosnippet>91</a>/// bool(input)
<a href=#92 id=92 data-nosnippet>92</a>/// }
<a href=#93 id=93 data-nosnippet>93</a>///
<a href=#94 id=94 data-nosnippet>94</a>/// assert_eq!(parse(([0b10000000].as_ref(), 0)), Ok((([0b10000000].as_ref(), 1), true)));
<a href=#95 id=95 data-nosnippet>95</a>/// assert_eq!(parse(([0b10000000].as_ref(), 1)), Ok((([0b10000000].as_ref(), 2), false)));
<a href=#96 id=96 data-nosnippet>96</a>/// ```
<a href=#97 id=97 data-nosnippet>97</a></span><span class="kw">pub fn </span>bool&lt;I, E: ParseError&lt;(I, usize)&gt;&gt;(input: (I, usize)) -&gt; IResult&lt;(I, usize), bool, E&gt;
<a href=#98 id=98 data-nosnippet>98</a><span class="kw">where
<a href=#99 id=99 data-nosnippet>99</a> </span>I: Input&lt;Item = u8&gt;,
<a href=#100 id=100 data-nosnippet>100</a>{
<a href=#101 id=101 data-nosnippet>101</a> <span class="kw">let </span>(res, bit): (<span class="kw">_</span>, u32) = take(<span class="number">1usize</span>)(input)<span class="question-mark">?</span>;
<a href=#102 id=102 data-nosnippet>102</a> <span class="prelude-val">Ok</span>((res, <span class="macro">bit !</span>= <span class="number">0</span>))
<a href=#103 id=103 data-nosnippet>103</a>}
<a href=#104 id=104 data-nosnippet>104</a>
<a href=#105 id=105 data-nosnippet>105</a><span class="attr">#[cfg(test)]
<a href=#106 id=106 data-nosnippet>106</a></span><span class="kw">mod </span>test {
<a href=#107 id=107 data-nosnippet>107</a> <span class="kw">use super</span>::<span class="kw-2">*</span>;
<a href=#108 id=108 data-nosnippet>108</a>
<a href=#109 id=109 data-nosnippet>109</a> <span class="attr">#[test]
<a href=#110 id=110 data-nosnippet>110</a> </span><span class="kw">fn </span>test_take_0() {
<a href=#111 id=111 data-nosnippet>111</a> <span class="kw">let </span>input = [].as_ref();
<a href=#112 id=112 data-nosnippet>112</a> <span class="kw">let </span>count = <span class="number">0usize</span>;
<a href=#113 id=113 data-nosnippet>113</a> <span class="macro">assert_eq!</span>(count, <span class="number">0usize</span>);
<a href=#114 id=114 data-nosnippet>114</a> <span class="kw">let </span>offset = <span class="number">0usize</span>;
<a href=#115 id=115 data-nosnippet>115</a>
<a href=#116 id=116 data-nosnippet>116</a> <span class="kw">let </span>result: <span class="kw">crate</span>::IResult&lt;(<span class="kw-2">&amp;</span>[u8], usize), usize&gt; = take(count)((input, offset));
<a href=#117 id=117 data-nosnippet>117</a>
<a href=#118 id=118 data-nosnippet>118</a> <span class="macro">assert_eq!</span>(result, <span class="prelude-val">Ok</span>(((input, offset), <span class="number">0</span>)));
<a href=#119 id=119 data-nosnippet>119</a> }
<a href=#120 id=120 data-nosnippet>120</a>
<a href=#121 id=121 data-nosnippet>121</a> <span class="attr">#[test]
<a href=#122 id=122 data-nosnippet>122</a> </span><span class="kw">fn </span>test_tag_ok() {
<a href=#123 id=123 data-nosnippet>123</a> <span class="kw">let </span>input = [<span class="number">0b00011111</span>].as_ref();
<a href=#124 id=124 data-nosnippet>124</a> <span class="kw">let </span>offset = <span class="number">0usize</span>;
<a href=#125 id=125 data-nosnippet>125</a> <span class="kw">let </span>bits_to_take = <span class="number">4usize</span>;
<a href=#126 id=126 data-nosnippet>126</a> <span class="kw">let </span>value_to_tag = <span class="number">0b0001</span>;
<a href=#127 id=127 data-nosnippet>127</a>
<a href=#128 id=128 data-nosnippet>128</a> <span class="kw">let </span>result: <span class="kw">crate</span>::IResult&lt;(<span class="kw-2">&amp;</span>[u8], usize), usize&gt; =
<a href=#129 id=129 data-nosnippet>129</a> tag(value_to_tag, bits_to_take)((input, offset));
<a href=#130 id=130 data-nosnippet>130</a>
<a href=#131 id=131 data-nosnippet>131</a> <span class="macro">assert_eq!</span>(result, <span class="prelude-val">Ok</span>(((input, bits_to_take), value_to_tag)));
<a href=#132 id=132 data-nosnippet>132</a> }
<a href=#133 id=133 data-nosnippet>133</a>
<a href=#134 id=134 data-nosnippet>134</a> <span class="attr">#[test]
<a href=#135 id=135 data-nosnippet>135</a> </span><span class="kw">fn </span>test_tag_err() {
<a href=#136 id=136 data-nosnippet>136</a> <span class="kw">let </span>input = [<span class="number">0b00011111</span>].as_ref();
<a href=#137 id=137 data-nosnippet>137</a> <span class="kw">let </span>offset = <span class="number">0usize</span>;
<a href=#138 id=138 data-nosnippet>138</a> <span class="kw">let </span>bits_to_take = <span class="number">4usize</span>;
<a href=#139 id=139 data-nosnippet>139</a> <span class="kw">let </span>value_to_tag = <span class="number">0b1111</span>;
<a href=#140 id=140 data-nosnippet>140</a>
<a href=#141 id=141 data-nosnippet>141</a> <span class="kw">let </span>result: <span class="kw">crate</span>::IResult&lt;(<span class="kw-2">&amp;</span>[u8], usize), usize&gt; =
<a href=#142 id=142 data-nosnippet>142</a> tag(value_to_tag, bits_to_take)((input, offset));
<a href=#143 id=143 data-nosnippet>143</a>
<a href=#144 id=144 data-nosnippet>144</a> <span class="macro">assert_eq!</span>(
<a href=#145 id=145 data-nosnippet>145</a> result,
<a href=#146 id=146 data-nosnippet>146</a> <span class="prelude-val">Err</span>(<span class="kw">crate</span>::Err::Error(<span class="kw">crate</span>::error::Error {
<a href=#147 id=147 data-nosnippet>147</a> input: (input, offset),
<a href=#148 id=148 data-nosnippet>148</a> code: ErrorKind::TagBits
<a href=#149 id=149 data-nosnippet>149</a> }))
<a href=#150 id=150 data-nosnippet>150</a> );
<a href=#151 id=151 data-nosnippet>151</a> }
<a href=#152 id=152 data-nosnippet>152</a>
<a href=#153 id=153 data-nosnippet>153</a> <span class="attr">#[test]
<a href=#154 id=154 data-nosnippet>154</a> </span><span class="kw">fn </span>test_bool_0() {
<a href=#155 id=155 data-nosnippet>155</a> <span class="kw">let </span>input = [<span class="number">0b10000000</span>].as_ref();
<a href=#156 id=156 data-nosnippet>156</a>
<a href=#157 id=157 data-nosnippet>157</a> <span class="kw">let </span>result: <span class="kw">crate</span>::IResult&lt;(<span class="kw-2">&amp;</span>[u8], usize), bool&gt; = bool((input, <span class="number">0</span>));
<a href=#158 id=158 data-nosnippet>158</a>
<a href=#159 id=159 data-nosnippet>159</a> <span class="macro">assert_eq!</span>(result, <span class="prelude-val">Ok</span>(((input, <span class="number">1</span>), <span class="bool-val">true</span>)));
<a href=#160 id=160 data-nosnippet>160</a> }
<a href=#161 id=161 data-nosnippet>161</a>
<a href=#162 id=162 data-nosnippet>162</a> <span class="attr">#[test]
<a href=#163 id=163 data-nosnippet>163</a> </span><span class="kw">fn </span>test_bool_eof() {
<a href=#164 id=164 data-nosnippet>164</a> <span class="kw">let </span>input = [<span class="number">0b10000000</span>].as_ref();
<a href=#165 id=165 data-nosnippet>165</a>
<a href=#166 id=166 data-nosnippet>166</a> <span class="kw">let </span>result: <span class="kw">crate</span>::IResult&lt;(<span class="kw-2">&amp;</span>[u8], usize), bool&gt; = bool((input, <span class="number">8</span>));
<a href=#167 id=167 data-nosnippet>167</a>
<a href=#168 id=168 data-nosnippet>168</a> <span class="macro">assert_eq!</span>(result, <span class="prelude-val">Err</span>(<span class="kw">crate</span>::Err::Incomplete(Needed::new(<span class="number">1</span>))));
<a href=#169 id=169 data-nosnippet>169</a> }
<a href=#170 id=170 data-nosnippet>170</a>}
</code></pre></div></section></main></body></html>
+373
View File
@@ -0,0 +1,373 @@
<!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 of the Rust file `/home/newkirk/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/nom-8.0.0/src/branch/mod.rs`."><title>mod.rs - source</title><script>if(window.location.protocol!=="file:")document.head.insertAdjacentHTML("beforeend","SourceSerif4-Regular-6b053e98.ttf.woff2,FiraSans-Italic-81dc35de.woff2,FiraSans-Regular-0fe48ade.woff2,FiraSans-MediumItalic-ccf7e434.woff2,FiraSans-Medium-e1aa3f0a.woff2,SourceCodePro-Regular-8badfe75.ttf.woff2,SourceCodePro-Semibold-aa29a496.ttf.woff2".split(",").map(f=>`<link rel="preload" as="font" type="font/woff2"href="../../../static.files/${f}">`).join(""))</script><link rel="stylesheet" href="../../../static.files/normalize-9960930a.css"><link rel="stylesheet" href="../../../static.files/rustdoc-ca0dd0c4.css"><meta name="rustdoc-vars" data-root-path="../../../" data-static-root-path="../../../static.files/" data-current-crate="nom" data-themes="" data-resource-suffix="" data-rustdoc-version="1.93.1 (01f6ddf75 2026-02-11) (Arch Linux rust 1:1.93.1-1)" data-channel="1.93.1" data-search-js="search-9e2438ea.js" data-stringdex-js="stringdex-a3946164.js" data-settings-js="settings-c38705f0.js" ><script src="../../../static.files/storage-e2aeef58.js"></script><script defer src="../../../static.files/src-script-813739b1.js"></script><script defer src="../../../src-files.js"></script><script defer src="../../../static.files/main-a410ff4d.js"></script><noscript><link rel="stylesheet" href="../../../static.files/noscript-263c88ec.css"></noscript><link rel="alternate icon" type="image/png" href="../../../static.files/favicon-32x32-eab170b8.png"><link rel="icon" type="image/svg+xml" href="../../../static.files/favicon-044be391.svg"></head><body class="rustdoc src"><!--[if lte IE 11]><div class="warning">This old browser is unsupported and will most likely display funky things.</div><![endif]--><nav class="sidebar"><div class="src-sidebar-title"><h2>Files</h2></div></nav><div class="sidebar-resizer" title="Drag to resize sidebar"></div><main><section id="main-content" class="content"><div class="main-heading"><h1><div class="sub-heading">nom/branch/</div>mod.rs</h1><rustdoc-toolbar></rustdoc-toolbar></div><div class="example-wrap digits-3"><pre class="rust"><code><a href=#1 id=1 data-nosnippet>1</a><span class="doccomment">//! Choice combinators
<a href=#2 id=2 data-nosnippet>2</a>
<a href=#3 id=3 data-nosnippet>3</a></span><span class="attr">#[cfg(test)]
<a href=#4 id=4 data-nosnippet>4</a></span><span class="kw">mod </span>tests;
<a href=#5 id=5 data-nosnippet>5</a>
<a href=#6 id=6 data-nosnippet>6</a><span class="kw">use </span>core::marker::PhantomData;
<a href=#7 id=7 data-nosnippet>7</a>
<a href=#8 id=8 data-nosnippet>8</a><span class="kw">use </span><span class="kw">crate</span>::error::ErrorKind;
<a href=#9 id=9 data-nosnippet>9</a><span class="kw">use </span><span class="kw">crate</span>::error::ParseError;
<a href=#10 id=10 data-nosnippet>10</a><span class="kw">use </span><span class="kw">crate</span>::internal::{<span class="prelude-val">Err</span>, Mode, Parser};
<a href=#11 id=11 data-nosnippet>11</a>
<a href=#12 id=12 data-nosnippet>12</a><span class="doccomment">/// Tests a list of parsers one by one until one succeeds.
<a href=#13 id=13 data-nosnippet>13</a>///
<a href=#14 id=14 data-nosnippet>14</a>/// It takes as argument either a tuple or an array of parsers. If using a
<a href=#15 id=15 data-nosnippet>15</a>/// tuple, there is a maximum of 21 parsers. If you need more, it is possible to
<a href=#16 id=16 data-nosnippet>16</a>/// use an array.
<a href=#17 id=17 data-nosnippet>17</a>///
<a href=#18 id=18 data-nosnippet>18</a>/// ```rust
<a href=#19 id=19 data-nosnippet>19</a>/// # use nom::error_position;
<a href=#20 id=20 data-nosnippet>20</a>/// # use nom::{Err,error::ErrorKind, Needed, IResult, Parser};
<a href=#21 id=21 data-nosnippet>21</a>/// use nom::character::complete::{alpha1, digit1};
<a href=#22 id=22 data-nosnippet>22</a>/// use nom::branch::alt;
<a href=#23 id=23 data-nosnippet>23</a>/// # fn main() {
<a href=#24 id=24 data-nosnippet>24</a>/// fn parser(input: &amp;str) -&gt; IResult&lt;&amp;str, &amp;str&gt; {
<a href=#25 id=25 data-nosnippet>25</a>/// alt((alpha1, digit1)).parse(input)
<a href=#26 id=26 data-nosnippet>26</a>/// };
<a href=#27 id=27 data-nosnippet>27</a>///
<a href=#28 id=28 data-nosnippet>28</a>/// // the first parser, alpha1, recognizes the input
<a href=#29 id=29 data-nosnippet>29</a>/// assert_eq!(parser("abc"), Ok(("", "abc")));
<a href=#30 id=30 data-nosnippet>30</a>///
<a href=#31 id=31 data-nosnippet>31</a>/// // the first parser returns an error, so alt tries the second one
<a href=#32 id=32 data-nosnippet>32</a>/// assert_eq!(parser("123456"), Ok(("", "123456")));
<a href=#33 id=33 data-nosnippet>33</a>///
<a href=#34 id=34 data-nosnippet>34</a>/// // both parsers failed, and with the default error type, alt will return the last error
<a href=#35 id=35 data-nosnippet>35</a>/// assert_eq!(parser(" "), Err(Err::Error(error_position!(" ", ErrorKind::Digit))));
<a href=#36 id=36 data-nosnippet>36</a>/// # }
<a href=#37 id=37 data-nosnippet>37</a>/// ```
<a href=#38 id=38 data-nosnippet>38</a>///
<a href=#39 id=39 data-nosnippet>39</a>/// With a custom error type, it is possible to have alt return the error of the parser
<a href=#40 id=40 data-nosnippet>40</a>/// that went the farthest in the input data
<a href=#41 id=41 data-nosnippet>41</a></span><span class="kw">pub fn </span>alt&lt;List&gt;(l: List) -&gt; Choice&lt;List&gt; {
<a href=#42 id=42 data-nosnippet>42</a> Choice { parser: l }
<a href=#43 id=43 data-nosnippet>43</a>}
<a href=#44 id=44 data-nosnippet>44</a>
<a href=#45 id=45 data-nosnippet>45</a><span class="doccomment">/// Applies a list of parsers in any order.
<a href=#46 id=46 data-nosnippet>46</a>///
<a href=#47 id=47 data-nosnippet>47</a>/// Permutation will succeed if all of the child parsers succeeded.
<a href=#48 id=48 data-nosnippet>48</a>/// It takes as argument a tuple of parsers, and returns a
<a href=#49 id=49 data-nosnippet>49</a>/// tuple of the parser results.
<a href=#50 id=50 data-nosnippet>50</a>///
<a href=#51 id=51 data-nosnippet>51</a>/// ```rust
<a href=#52 id=52 data-nosnippet>52</a>/// # use nom::{Err,error::{Error, ErrorKind}, Needed, IResult, Parser};
<a href=#53 id=53 data-nosnippet>53</a>/// use nom::character::complete::{alpha1, digit1};
<a href=#54 id=54 data-nosnippet>54</a>/// use nom::branch::permutation;
<a href=#55 id=55 data-nosnippet>55</a>/// # fn main() {
<a href=#56 id=56 data-nosnippet>56</a>/// fn parser(input: &amp;str) -&gt; IResult&lt;&amp;str, (&amp;str, &amp;str)&gt; {
<a href=#57 id=57 data-nosnippet>57</a>/// permutation((alpha1, digit1)).parse(input)
<a href=#58 id=58 data-nosnippet>58</a>/// }
<a href=#59 id=59 data-nosnippet>59</a>///
<a href=#60 id=60 data-nosnippet>60</a>/// // permutation recognizes alphabetic characters then digit
<a href=#61 id=61 data-nosnippet>61</a>/// assert_eq!(parser("abc123"), Ok(("", ("abc", "123"))));
<a href=#62 id=62 data-nosnippet>62</a>///
<a href=#63 id=63 data-nosnippet>63</a>/// // but also in inverse order
<a href=#64 id=64 data-nosnippet>64</a>/// assert_eq!(parser("123abc"), Ok(("", ("abc", "123"))));
<a href=#65 id=65 data-nosnippet>65</a>///
<a href=#66 id=66 data-nosnippet>66</a>/// // it will fail if one of the parsers failed
<a href=#67 id=67 data-nosnippet>67</a>/// assert_eq!(parser("abc;"), Err(Err::Error(Error::new(";", ErrorKind::Digit))));
<a href=#68 id=68 data-nosnippet>68</a>/// # }
<a href=#69 id=69 data-nosnippet>69</a>/// ```
<a href=#70 id=70 data-nosnippet>70</a>///
<a href=#71 id=71 data-nosnippet>71</a>/// The parsers are applied greedily: if there are multiple unapplied parsers
<a href=#72 id=72 data-nosnippet>72</a>/// that could parse the next slice of input, the first one is used.
<a href=#73 id=73 data-nosnippet>73</a>/// ```rust
<a href=#74 id=74 data-nosnippet>74</a>/// # use nom::{Err, error::{Error, ErrorKind}, IResult, Parser};
<a href=#75 id=75 data-nosnippet>75</a>/// use nom::branch::permutation;
<a href=#76 id=76 data-nosnippet>76</a>/// use nom::character::complete::{anychar, char};
<a href=#77 id=77 data-nosnippet>77</a>///
<a href=#78 id=78 data-nosnippet>78</a>/// fn parser(input: &amp;str) -&gt; IResult&lt;&amp;str, (char, char)&gt; {
<a href=#79 id=79 data-nosnippet>79</a>/// permutation((anychar, char('a'))).parse(input)
<a href=#80 id=80 data-nosnippet>80</a>/// }
<a href=#81 id=81 data-nosnippet>81</a>///
<a href=#82 id=82 data-nosnippet>82</a>/// // anychar parses 'b', then char('a') parses 'a'
<a href=#83 id=83 data-nosnippet>83</a>/// assert_eq!(parser("ba"), Ok(("", ('b', 'a'))));
<a href=#84 id=84 data-nosnippet>84</a>///
<a href=#85 id=85 data-nosnippet>85</a>/// // anychar parses 'a', then char('a') fails on 'b',
<a href=#86 id=86 data-nosnippet>86</a>/// // even though char('a') followed by anychar would succeed
<a href=#87 id=87 data-nosnippet>87</a>/// assert_eq!(parser("ab"), Err(Err::Error(Error::new("b", ErrorKind::Char))));
<a href=#88 id=88 data-nosnippet>88</a>/// ```
<a href=#89 id=89 data-nosnippet>89</a>///
<a href=#90 id=90 data-nosnippet>90</a></span><span class="kw">pub fn </span>permutation&lt;I: Clone, E: ParseError&lt;I&gt;, List&gt;(list: List) -&gt; Permutation&lt;List, E&gt; {
<a href=#91 id=91 data-nosnippet>91</a> Permutation {
<a href=#92 id=92 data-nosnippet>92</a> parser: list,
<a href=#93 id=93 data-nosnippet>93</a> e: PhantomData,
<a href=#94 id=94 data-nosnippet>94</a> }
<a href=#95 id=95 data-nosnippet>95</a>}
<a href=#96 id=96 data-nosnippet>96</a>
<a href=#97 id=97 data-nosnippet>97</a><span class="macro">macro_rules!</span> alt_trait(
<a href=#98 id=98 data-nosnippet>98</a> (<span class="macro-nonterminal">$first</span>:ident <span class="macro-nonterminal">$second</span>:ident $(<span class="macro-nonterminal">$id</span>: ident)+) =&gt; (
<a href=#99 id=99 data-nosnippet>99</a> <span class="macro">alt_trait!</span>(__impl <span class="macro-nonterminal">$first $second</span>; $(<span class="macro-nonterminal">$id</span>)+);
<a href=#100 id=100 data-nosnippet>100</a> );
<a href=#101 id=101 data-nosnippet>101</a> (__impl $(<span class="macro-nonterminal">$current</span>:ident)<span class="kw-2">*</span>; <span class="macro-nonterminal">$head</span>:ident $(<span class="macro-nonterminal">$id</span>: ident)+) =&gt; (
<a href=#102 id=102 data-nosnippet>102</a> <span class="macro">alt_trait_impl!</span>($(<span class="macro-nonterminal">$current</span>)<span class="kw-2">*</span>);
<a href=#103 id=103 data-nosnippet>103</a>
<a href=#104 id=104 data-nosnippet>104</a> <span class="macro">alt_trait!</span>(__impl $(<span class="macro-nonterminal">$current</span>)* <span class="macro-nonterminal">$head</span>; $(<span class="macro-nonterminal">$id</span>)+);
<a href=#105 id=105 data-nosnippet>105</a> );
<a href=#106 id=106 data-nosnippet>106</a> (__impl $(<span class="macro-nonterminal">$current</span>:ident)<span class="kw-2">*</span>; <span class="macro-nonterminal">$head</span>:ident) =&gt; (
<a href=#107 id=107 data-nosnippet>107</a> <span class="macro">alt_trait_impl!</span>($(<span class="macro-nonterminal">$current</span>)<span class="kw-2">*</span>);
<a href=#108 id=108 data-nosnippet>108</a> <span class="macro">alt_trait_impl!</span>($(<span class="macro-nonterminal">$current</span>)* <span class="macro-nonterminal">$head</span>);
<a href=#109 id=109 data-nosnippet>109</a> );
<a href=#110 id=110 data-nosnippet>110</a>);
<a href=#111 id=111 data-nosnippet>111</a>
<a href=#112 id=112 data-nosnippet>112</a><span class="doccomment">/// Wrapping structure for the [alt()] combinator implementation
<a href=#113 id=113 data-nosnippet>113</a></span><span class="kw">pub struct </span>Choice&lt;T&gt; {
<a href=#114 id=114 data-nosnippet>114</a> parser: T,
<a href=#115 id=115 data-nosnippet>115</a>}
<a href=#116 id=116 data-nosnippet>116</a>
<a href=#117 id=117 data-nosnippet>117</a><span class="macro">macro_rules!</span> alt_trait_impl(
<a href=#118 id=118 data-nosnippet>118</a> ($(<span class="macro-nonterminal">$id</span>:ident)+) =&gt; (
<a href=#119 id=119 data-nosnippet>119</a> <span class="kw">impl</span>&lt;
<a href=#120 id=120 data-nosnippet>120</a> Input: Clone, Output, Error: ParseError&lt;Input&gt;,
<a href=#121 id=121 data-nosnippet>121</a> $(<span class="macro-nonterminal">$id</span>: Parser&lt;Input, Output = Output, Error = Error&gt;),+
<a href=#122 id=122 data-nosnippet>122</a> &gt; Parser&lt;Input&gt; <span class="kw">for </span>Choice&lt; ( $(<span class="macro-nonterminal">$id</span>),+ )&gt; {
<a href=#123 id=123 data-nosnippet>123</a> <span class="kw">type </span>Output = Output;
<a href=#124 id=124 data-nosnippet>124</a> <span class="kw">type </span>Error = Error;
<a href=#125 id=125 data-nosnippet>125</a>
<a href=#126 id=126 data-nosnippet>126</a> <span class="attr">#[inline(always)]
<a href=#127 id=127 data-nosnippet>127</a> </span><span class="kw">fn </span>process&lt;OM: <span class="kw">crate</span>::OutputMode&gt;(
<a href=#128 id=128 data-nosnippet>128</a> <span class="kw-2">&amp;mut </span><span class="self">self</span>,
<a href=#129 id=129 data-nosnippet>129</a> input: Input,
<a href=#130 id=130 data-nosnippet>130</a> ) -&gt; <span class="kw">crate</span>::PResult&lt;OM, Input, <span class="self">Self</span>::Output, <span class="self">Self</span>::Error&gt; {
<a href=#131 id=131 data-nosnippet>131</a> <span class="kw">match </span><span class="self">self</span>.parser.<span class="number">0</span>.process::&lt;OM&gt;(input.clone()) {
<a href=#132 id=132 data-nosnippet>132</a> <span class="prelude-val">Ok</span>(res) =&gt; <span class="prelude-val">Ok</span>(res),
<a href=#133 id=133 data-nosnippet>133</a> <span class="prelude-val">Err</span>(Err::Failure(e))=&gt; <span class="prelude-val">Err</span>(Err::Failure(e)),
<a href=#134 id=134 data-nosnippet>134</a> <span class="prelude-val">Err</span>(Err::Incomplete(i))=&gt; <span class="prelude-val">Err</span>(Err::Incomplete(i)),
<a href=#135 id=135 data-nosnippet>135</a> <span class="prelude-val">Err</span>(Err::Error(e)) =&gt; <span class="macro">alt_trait_inner!</span>(<span class="number">1</span>, <span class="self">self</span>, input, e, $(<span class="macro-nonterminal">$id</span>)+),
<a href=#136 id=136 data-nosnippet>136</a> }
<a href=#137 id=137 data-nosnippet>137</a> }
<a href=#138 id=138 data-nosnippet>138</a> }
<a href=#139 id=139 data-nosnippet>139</a> );
<a href=#140 id=140 data-nosnippet>140</a>);
<a href=#141 id=141 data-nosnippet>141</a>
<a href=#142 id=142 data-nosnippet>142</a><span class="macro">macro_rules!</span> alt_trait_inner(
<a href=#143 id=143 data-nosnippet>143</a> (<span class="macro-nonterminal">$it</span>:tt, <span class="macro-nonterminal">$self</span>:expr, <span class="macro-nonterminal">$input</span>:expr, <span class="macro-nonterminal">$err</span>:expr, <span class="macro-nonterminal">$head</span>:ident $(<span class="macro-nonterminal">$id</span>:ident)+) =&gt; (
<a href=#144 id=144 data-nosnippet>144</a> <span class="kw">match </span><span class="macro-nonterminal">$self</span>.parser.<span class="macro-nonterminal">$it</span>.process::&lt;OM&gt;(<span class="macro-nonterminal">$input</span>.clone()) {
<a href=#145 id=145 data-nosnippet>145</a> <span class="prelude-val">Ok</span>(res) =&gt; <span class="prelude-val">Ok</span>(res),
<a href=#146 id=146 data-nosnippet>146</a> <span class="prelude-val">Err</span>(Err::Failure(e))=&gt;<span class="prelude-val">Err</span>(Err::Failure(e)),
<a href=#147 id=147 data-nosnippet>147</a> <span class="prelude-val">Err</span>(Err::Incomplete(i))=&gt; <span class="prelude-val">Err</span>(Err::Incomplete(i)),
<a href=#148 id=148 data-nosnippet>148</a> <span class="prelude-val">Err</span>(Err::Error(e)) =&gt; {
<a href=#149 id=149 data-nosnippet>149</a> <span class="macro">succ!</span>(<span class="macro-nonterminal">$it</span>, <span class="macro">alt_trait_inner!</span>(<span class="macro-nonterminal">$self</span>, <span class="macro-nonterminal">$input</span>, &lt;OM::Error <span class="kw">as </span><span class="kw">crate</span>::Mode&gt;::combine(<span class="macro-nonterminal">$err</span>, e, |e1, e2| e1.or(e2)), $(<span class="macro-nonterminal">$id</span>)+))
<a href=#150 id=150 data-nosnippet>150</a> }
<a href=#151 id=151 data-nosnippet>151</a> }
<a href=#152 id=152 data-nosnippet>152</a> );
<a href=#153 id=153 data-nosnippet>153</a> (<span class="macro-nonterminal">$it</span>:tt, <span class="macro-nonterminal">$self</span>:expr, <span class="macro-nonterminal">$input</span>:expr, <span class="macro-nonterminal">$err</span>:expr, <span class="macro-nonterminal">$head</span>:ident) =&gt; (
<a href=#154 id=154 data-nosnippet>154</a> <span class="prelude-val">Err</span>(Err::Error(&lt;OM::Error <span class="kw">as </span><span class="kw">crate</span>::Mode&gt;::map(<span class="macro-nonterminal">$err</span>, |err| Error::append(<span class="macro-nonterminal">$input</span>, ErrorKind::Alt, err))))
<a href=#155 id=155 data-nosnippet>155</a> );
<a href=#156 id=156 data-nosnippet>156</a>);
<a href=#157 id=157 data-nosnippet>157</a>
<a href=#158 id=158 data-nosnippet>158</a><span class="macro">alt_trait!</span>(A B C D E F G H I J K L M N O P Q R S T U);
<a href=#159 id=159 data-nosnippet>159</a>
<a href=#160 id=160 data-nosnippet>160</a><span class="comment">// Manually implement Alt for (A,), the 1-tuple type
<a href=#161 id=161 data-nosnippet>161</a></span><span class="kw">impl</span>&lt;Input, Output, Error: ParseError&lt;Input&gt;, A: Parser&lt;Input, Output = Output, Error = Error&gt;&gt;
<a href=#162 id=162 data-nosnippet>162</a> Parser&lt;Input&gt; <span class="kw">for </span>Choice&lt;(A,)&gt;
<a href=#163 id=163 data-nosnippet>163</a>{
<a href=#164 id=164 data-nosnippet>164</a> <span class="kw">type </span>Output = Output;
<a href=#165 id=165 data-nosnippet>165</a> <span class="kw">type </span>Error = Error;
<a href=#166 id=166 data-nosnippet>166</a>
<a href=#167 id=167 data-nosnippet>167</a> <span class="attr">#[inline]
<a href=#168 id=168 data-nosnippet>168</a> </span><span class="kw">fn </span>process&lt;OM: <span class="kw">crate</span>::OutputMode&gt;(
<a href=#169 id=169 data-nosnippet>169</a> <span class="kw-2">&amp;mut </span><span class="self">self</span>,
<a href=#170 id=170 data-nosnippet>170</a> input: Input,
<a href=#171 id=171 data-nosnippet>171</a> ) -&gt; <span class="kw">crate</span>::PResult&lt;OM, Input, <span class="self">Self</span>::Output, <span class="self">Self</span>::Error&gt; {
<a href=#172 id=172 data-nosnippet>172</a> <span class="self">self</span>.parser.<span class="number">0</span>.process::&lt;OM&gt;(input)
<a href=#173 id=173 data-nosnippet>173</a> }
<a href=#174 id=174 data-nosnippet>174</a>}
<a href=#175 id=175 data-nosnippet>175</a>
<a href=#176 id=176 data-nosnippet>176</a><span class="kw">impl</span>&lt;
<a href=#177 id=177 data-nosnippet>177</a> <span class="kw">const </span>N: usize,
<a href=#178 id=178 data-nosnippet>178</a> Input: Clone,
<a href=#179 id=179 data-nosnippet>179</a> Output,
<a href=#180 id=180 data-nosnippet>180</a> Error: ParseError&lt;Input&gt;,
<a href=#181 id=181 data-nosnippet>181</a> A: Parser&lt;Input, Output = Output, Error = Error&gt;,
<a href=#182 id=182 data-nosnippet>182</a> &gt; Parser&lt;Input&gt; <span class="kw">for </span>Choice&lt;[A; N]&gt;
<a href=#183 id=183 data-nosnippet>183</a>{
<a href=#184 id=184 data-nosnippet>184</a> <span class="kw">type </span>Output = Output;
<a href=#185 id=185 data-nosnippet>185</a> <span class="kw">type </span>Error = Error;
<a href=#186 id=186 data-nosnippet>186</a>
<a href=#187 id=187 data-nosnippet>187</a> <span class="attr">#[inline]
<a href=#188 id=188 data-nosnippet>188</a> </span><span class="kw">fn </span>process&lt;OM: <span class="kw">crate</span>::OutputMode&gt;(
<a href=#189 id=189 data-nosnippet>189</a> <span class="kw-2">&amp;mut </span><span class="self">self</span>,
<a href=#190 id=190 data-nosnippet>190</a> input: Input,
<a href=#191 id=191 data-nosnippet>191</a> ) -&gt; <span class="kw">crate</span>::PResult&lt;OM, Input, <span class="self">Self</span>::Output, <span class="self">Self</span>::Error&gt; {
<a href=#192 id=192 data-nosnippet>192</a> <span class="kw">let </span><span class="kw-2">mut </span>error = <span class="prelude-val">None</span>;
<a href=#193 id=193 data-nosnippet>193</a>
<a href=#194 id=194 data-nosnippet>194</a> <span class="kw">for </span>branch <span class="kw">in </span><span class="kw-2">&amp;mut </span><span class="self">self</span>.parser {
<a href=#195 id=195 data-nosnippet>195</a> <span class="kw">match </span>branch.process::&lt;OM&gt;(input.clone()) {
<a href=#196 id=196 data-nosnippet>196</a> <span class="prelude-val">Err</span>(Err::Error(e)) =&gt; <span class="kw">match </span>error {
<a href=#197 id=197 data-nosnippet>197</a> <span class="prelude-val">None </span>=&gt; error = <span class="prelude-val">Some</span>(e),
<a href=#198 id=198 data-nosnippet>198</a> <span class="prelude-val">Some</span>(err) =&gt; error = <span class="prelude-val">Some</span>(OM::Error::combine(err, e, |e1, e2| e1.or(e2))),
<a href=#199 id=199 data-nosnippet>199</a> },
<a href=#200 id=200 data-nosnippet>200</a> res =&gt; <span class="kw">return </span>res,
<a href=#201 id=201 data-nosnippet>201</a> }
<a href=#202 id=202 data-nosnippet>202</a> }
<a href=#203 id=203 data-nosnippet>203</a>
<a href=#204 id=204 data-nosnippet>204</a> <span class="kw">match </span>error {
<a href=#205 id=205 data-nosnippet>205</a> <span class="prelude-val">Some</span>(e) =&gt; <span class="prelude-val">Err</span>(Err::Error(OM::Error::map(e, |err| {
<a href=#206 id=206 data-nosnippet>206</a> Error::append(input, ErrorKind::Alt, err)
<a href=#207 id=207 data-nosnippet>207</a> }))),
<a href=#208 id=208 data-nosnippet>208</a> <span class="prelude-val">None </span>=&gt; <span class="prelude-val">Err</span>(Err::Error(OM::Error::bind(|| {
<a href=#209 id=209 data-nosnippet>209</a> Error::from_error_kind(input, ErrorKind::Alt)
<a href=#210 id=210 data-nosnippet>210</a> }))),
<a href=#211 id=211 data-nosnippet>211</a> }
<a href=#212 id=212 data-nosnippet>212</a> }
<a href=#213 id=213 data-nosnippet>213</a>}
<a href=#214 id=214 data-nosnippet>214</a>
<a href=#215 id=215 data-nosnippet>215</a><span class="kw">impl</span>&lt;
<a href=#216 id=216 data-nosnippet>216</a> Input: Clone,
<a href=#217 id=217 data-nosnippet>217</a> Output,
<a href=#218 id=218 data-nosnippet>218</a> Error: ParseError&lt;Input&gt;,
<a href=#219 id=219 data-nosnippet>219</a> A: Parser&lt;Input, Output = Output, Error = Error&gt;,
<a href=#220 id=220 data-nosnippet>220</a> &gt; Parser&lt;Input&gt; <span class="kw">for </span>Choice&lt;<span class="kw-2">&amp;mut </span>[A]&gt;
<a href=#221 id=221 data-nosnippet>221</a>{
<a href=#222 id=222 data-nosnippet>222</a> <span class="kw">type </span>Output = Output;
<a href=#223 id=223 data-nosnippet>223</a> <span class="kw">type </span>Error = Error;
<a href=#224 id=224 data-nosnippet>224</a>
<a href=#225 id=225 data-nosnippet>225</a> <span class="attr">#[inline]
<a href=#226 id=226 data-nosnippet>226</a> </span><span class="kw">fn </span>process&lt;OM: <span class="kw">crate</span>::OutputMode&gt;(
<a href=#227 id=227 data-nosnippet>227</a> <span class="kw-2">&amp;mut </span><span class="self">self</span>,
<a href=#228 id=228 data-nosnippet>228</a> input: Input,
<a href=#229 id=229 data-nosnippet>229</a> ) -&gt; <span class="kw">crate</span>::PResult&lt;OM, Input, <span class="self">Self</span>::Output, <span class="self">Self</span>::Error&gt; {
<a href=#230 id=230 data-nosnippet>230</a> <span class="kw">let </span><span class="kw-2">mut </span>error = <span class="prelude-val">None</span>;
<a href=#231 id=231 data-nosnippet>231</a>
<a href=#232 id=232 data-nosnippet>232</a> <span class="kw">for </span>branch <span class="kw">in </span><span class="self">self</span>.parser.iter_mut() {
<a href=#233 id=233 data-nosnippet>233</a> <span class="kw">match </span>branch.process::&lt;OM&gt;(input.clone()) {
<a href=#234 id=234 data-nosnippet>234</a> <span class="prelude-val">Err</span>(Err::Error(e)) =&gt; <span class="kw">match </span>error {
<a href=#235 id=235 data-nosnippet>235</a> <span class="prelude-val">None </span>=&gt; error = <span class="prelude-val">Some</span>(e),
<a href=#236 id=236 data-nosnippet>236</a> <span class="prelude-val">Some</span>(err) =&gt; error = <span class="prelude-val">Some</span>(OM::Error::combine(err, e, |e1, e2| e1.or(e2))),
<a href=#237 id=237 data-nosnippet>237</a> },
<a href=#238 id=238 data-nosnippet>238</a> res =&gt; <span class="kw">return </span>res,
<a href=#239 id=239 data-nosnippet>239</a> }
<a href=#240 id=240 data-nosnippet>240</a> }
<a href=#241 id=241 data-nosnippet>241</a>
<a href=#242 id=242 data-nosnippet>242</a> <span class="kw">match </span>error {
<a href=#243 id=243 data-nosnippet>243</a> <span class="prelude-val">Some</span>(e) =&gt; <span class="prelude-val">Err</span>(Err::Error(OM::Error::map(e, |err| {
<a href=#244 id=244 data-nosnippet>244</a> Error::append(input, ErrorKind::Alt, err)
<a href=#245 id=245 data-nosnippet>245</a> }))),
<a href=#246 id=246 data-nosnippet>246</a> <span class="prelude-val">None </span>=&gt; <span class="prelude-val">Err</span>(Err::Error(OM::Error::bind(|| {
<a href=#247 id=247 data-nosnippet>247</a> Error::from_error_kind(input, ErrorKind::Alt)
<a href=#248 id=248 data-nosnippet>248</a> }))),
<a href=#249 id=249 data-nosnippet>249</a> }
<a href=#250 id=250 data-nosnippet>250</a> }
<a href=#251 id=251 data-nosnippet>251</a>}
<a href=#252 id=252 data-nosnippet>252</a>
<a href=#253 id=253 data-nosnippet>253</a><span class="macro">macro_rules!</span> permutation_trait(
<a href=#254 id=254 data-nosnippet>254</a> (
<a href=#255 id=255 data-nosnippet>255</a> <span class="macro-nonterminal">$name1</span>:ident <span class="macro-nonterminal">$ty1</span>:ident <span class="macro-nonterminal">$item1</span>:ident
<a href=#256 id=256 data-nosnippet>256</a> <span class="macro-nonterminal">$name2</span>:ident <span class="macro-nonterminal">$ty2</span>:ident <span class="macro-nonterminal">$item2</span>:ident
<a href=#257 id=257 data-nosnippet>257</a> $(<span class="macro-nonterminal">$name3</span>:ident <span class="macro-nonterminal">$ty3</span>:ident <span class="macro-nonterminal">$item3</span>:ident)*
<a href=#258 id=258 data-nosnippet>258</a> ) =&gt; (
<a href=#259 id=259 data-nosnippet>259</a> <span class="macro">permutation_trait!</span>(__impl <span class="macro-nonterminal">$name1 $ty1 $item1</span>, <span class="macro-nonterminal">$name2 $ty2 $item2</span>; $(<span class="macro-nonterminal">$name3 $ty3 $item3</span>)<span class="kw-2">*</span>);
<a href=#260 id=260 data-nosnippet>260</a> );
<a href=#261 id=261 data-nosnippet>261</a> (
<a href=#262 id=262 data-nosnippet>262</a> __impl $(<span class="macro-nonterminal">$name</span>:ident <span class="macro-nonterminal">$ty</span>:ident <span class="macro-nonterminal">$item</span>:ident),+;
<a href=#263 id=263 data-nosnippet>263</a> <span class="macro-nonterminal">$name1</span>:ident <span class="macro-nonterminal">$ty1</span>:ident <span class="macro-nonterminal">$item1</span>:ident $(<span class="macro-nonterminal">$name2</span>:ident <span class="macro-nonterminal">$ty2</span>:ident <span class="macro-nonterminal">$item2</span>:ident)*
<a href=#264 id=264 data-nosnippet>264</a> ) =&gt; (
<a href=#265 id=265 data-nosnippet>265</a> <span class="macro">permutation_trait_impl!</span>($(<span class="macro-nonterminal">$name $ty $item</span>),+);
<a href=#266 id=266 data-nosnippet>266</a> <span class="macro">permutation_trait!</span>(__impl $(<span class="macro-nonterminal">$name $ty $item</span>),+ , <span class="macro-nonterminal">$name1 $ty1 $item1</span>; $(<span class="macro-nonterminal">$name2 $ty2 $item2</span>)<span class="kw-2">*</span>);
<a href=#267 id=267 data-nosnippet>267</a> );
<a href=#268 id=268 data-nosnippet>268</a> (__impl $(<span class="macro-nonterminal">$name</span>:ident <span class="macro-nonterminal">$ty</span>:ident <span class="macro-nonterminal">$item</span>:ident),+;) =&gt; (
<a href=#269 id=269 data-nosnippet>269</a> <span class="macro">permutation_trait_impl!</span>($(<span class="macro-nonterminal">$name $ty $item</span>),+);
<a href=#270 id=270 data-nosnippet>270</a> );
<a href=#271 id=271 data-nosnippet>271</a>);
<a href=#272 id=272 data-nosnippet>272</a>
<a href=#273 id=273 data-nosnippet>273</a><span class="doccomment">/// Wrapping structure for the [permutation] combinator implementation
<a href=#274 id=274 data-nosnippet>274</a></span><span class="kw">pub struct </span>Permutation&lt;T, Error&gt; {
<a href=#275 id=275 data-nosnippet>275</a> parser: T,
<a href=#276 id=276 data-nosnippet>276</a> e: PhantomData&lt;Error&gt;,
<a href=#277 id=277 data-nosnippet>277</a>}
<a href=#278 id=278 data-nosnippet>278</a>
<a href=#279 id=279 data-nosnippet>279</a><span class="macro">macro_rules!</span> permutation_trait_impl(
<a href=#280 id=280 data-nosnippet>280</a> ($(<span class="macro-nonterminal">$name</span>:ident <span class="macro-nonterminal">$ty</span>:ident <span class="macro-nonterminal">$item</span>:ident),+) =&gt; (
<a href=#281 id=281 data-nosnippet>281</a> <span class="kw">impl</span>&lt;
<a href=#282 id=282 data-nosnippet>282</a> Input, Error, $(<span class="macro-nonterminal">$ty</span>),+ , $(<span class="macro-nonterminal">$name</span>),+
<a href=#283 id=283 data-nosnippet>283</a> &gt; Parser&lt;Input&gt; <span class="kw">for </span>Permutation&lt; ( $(<span class="macro-nonterminal">$name</span>),+ ), Error&gt;
<a href=#284 id=284 data-nosnippet>284</a> <span class="kw">where
<a href=#285 id=285 data-nosnippet>285</a> </span>Input: Clone,
<a href=#286 id=286 data-nosnippet>286</a> Error: ParseError&lt;Input&gt;,
<a href=#287 id=287 data-nosnippet>287</a> $(<span class="macro-nonterminal">$name</span>: Parser&lt;Input, Output = <span class="macro-nonterminal">$ty</span>, Error = Error&gt;),+
<a href=#288 id=288 data-nosnippet>288</a> {
<a href=#289 id=289 data-nosnippet>289</a> <span class="kw">type </span>Output = ( $(<span class="macro-nonterminal">$ty</span>),+ );
<a href=#290 id=290 data-nosnippet>290</a> <span class="kw">type </span>Error = Error;
<a href=#291 id=291 data-nosnippet>291</a>
<a href=#292 id=292 data-nosnippet>292</a> <span class="attr">#[inline(always)]
<a href=#293 id=293 data-nosnippet>293</a> </span><span class="kw">fn </span>process&lt;OM: <span class="kw">crate</span>::OutputMode&gt;(
<a href=#294 id=294 data-nosnippet>294</a> <span class="kw-2">&amp;mut </span><span class="self">self</span>,
<a href=#295 id=295 data-nosnippet>295</a> <span class="kw-2">mut </span>input: Input,
<a href=#296 id=296 data-nosnippet>296</a> ) -&gt; <span class="kw">crate</span>::PResult&lt;OM, Input, <span class="self">Self</span>::Output, <span class="self">Self</span>::Error&gt; {
<a href=#297 id=297 data-nosnippet>297</a> <span class="kw">let </span><span class="kw-2">mut </span>res = OM::Output::bind(|| ($(<span class="prelude-ty">Option</span>::&lt;<span class="macro-nonterminal">$ty</span>&gt;::None),+));
<a href=#298 id=298 data-nosnippet>298</a> $(<span class="kw">let </span><span class="kw-2">mut </span><span class="macro-nonterminal">$item </span>= <span class="bool-val">false</span>;)+
<a href=#299 id=299 data-nosnippet>299</a>
<a href=#300 id=300 data-nosnippet>300</a> <span class="kw">loop </span>{
<a href=#301 id=301 data-nosnippet>301</a> <span class="kw">let </span><span class="kw-2">mut </span>err: <span class="prelude-ty">Option</span>&lt;&lt;OM::Error <span class="kw">as </span>Mode&gt;::Output&lt;Error&gt;&gt; = <span class="prelude-val">None</span>;
<a href=#302 id=302 data-nosnippet>302</a> <span class="macro">permutation_trait_inner!</span>(<span class="number">0</span>, <span class="self">self</span>, input, res, err, $(<span class="macro-nonterminal">$item</span>)+);
<a href=#303 id=303 data-nosnippet>303</a>
<a href=#304 id=304 data-nosnippet>304</a> <span class="comment">// If we reach here, every iterator has either been applied before,
<a href=#305 id=305 data-nosnippet>305</a> // or errored on the remaining input
<a href=#306 id=306 data-nosnippet>306</a> </span><span class="kw">if let </span><span class="prelude-val">Some</span>(err) = err {
<a href=#307 id=307 data-nosnippet>307</a> <span class="comment">// There are remaining parsers, and all errored on the remaining input
<a href=#308 id=308 data-nosnippet>308</a> </span><span class="kw">return </span><span class="prelude-val">Err</span>(Err::Error(OM::Error::map(err, |err| Error::append(input, ErrorKind::Permutation, err))));
<a href=#309 id=309 data-nosnippet>309</a> }
<a href=#310 id=310 data-nosnippet>310</a>
<a href=#311 id=311 data-nosnippet>311</a> <span class="kw">return </span><span class="prelude-val">Ok</span>((input,OM::Output::map(res, |res| {
<a href=#312 id=312 data-nosnippet>312</a> <span class="comment">// All parsers were applied
<a href=#313 id=313 data-nosnippet>313</a> </span><span class="kw">match </span>res {
<a href=#314 id=314 data-nosnippet>314</a> ($(<span class="prelude-val">Some</span>(<span class="macro-nonterminal">$item</span>)),+) =&gt; ($(<span class="macro-nonterminal">$item</span>),+),
<a href=#315 id=315 data-nosnippet>315</a> <span class="kw">_ </span>=&gt; <span class="macro">unreachable!</span>(),
<a href=#316 id=316 data-nosnippet>316</a> }
<a href=#317 id=317 data-nosnippet>317</a> })))
<a href=#318 id=318 data-nosnippet>318</a> }
<a href=#319 id=319 data-nosnippet>319</a> }
<a href=#320 id=320 data-nosnippet>320</a>
<a href=#321 id=321 data-nosnippet>321</a> }
<a href=#322 id=322 data-nosnippet>322</a> );
<a href=#323 id=323 data-nosnippet>323</a>);
<a href=#324 id=324 data-nosnippet>324</a>
<a href=#325 id=325 data-nosnippet>325</a><span class="macro">macro_rules!</span> permutation_trait_inner(
<a href=#326 id=326 data-nosnippet>326</a> (<span class="macro-nonterminal">$it</span>:tt, <span class="macro-nonterminal">$self</span>:expr, <span class="macro-nonterminal">$input</span>:ident, <span class="macro-nonterminal">$res</span>:expr, <span class="macro-nonterminal">$err</span>:expr, <span class="macro-nonterminal">$head</span>:ident $(<span class="macro-nonterminal">$item</span>:ident)<span class="kw-2">*</span>) =&gt; (
<a href=#327 id=327 data-nosnippet>327</a> <span class="kw">if </span>!<span class="macro-nonterminal">$head </span>{
<a href=#328 id=328 data-nosnippet>328</a>
<a href=#329 id=329 data-nosnippet>329</a> <span class="kw">match </span><span class="macro-nonterminal">$self</span>.parser.<span class="macro-nonterminal">$it</span>.process::&lt;OM&gt;(<span class="macro-nonterminal">$input</span>.clone()) {
<a href=#330 id=330 data-nosnippet>330</a> <span class="prelude-val">Ok</span>((i, o)) =&gt; {
<a href=#331 id=331 data-nosnippet>331</a> <span class="macro-nonterminal">$input </span>= i;
<a href=#332 id=332 data-nosnippet>332</a> <span class="macro-nonterminal">$res </span>= OM::Output::combine(<span class="macro-nonterminal">$res</span>, o, |<span class="kw-2">mut </span>res, o | {res.<span class="macro-nonterminal">$it </span>= <span class="prelude-val">Some</span>(o);res });
<a href=#333 id=333 data-nosnippet>333</a> <span class="macro-nonterminal">$head </span>= <span class="bool-val">true</span>;
<a href=#334 id=334 data-nosnippet>334</a> <span class="kw">continue</span>;
<a href=#335 id=335 data-nosnippet>335</a> }
<a href=#336 id=336 data-nosnippet>336</a> <span class="prelude-val">Err</span>(Err::Error(e)) =&gt; {
<a href=#337 id=337 data-nosnippet>337</a> <span class="macro-nonterminal">$err </span>= <span class="prelude-val">Some</span>(<span class="kw">match </span><span class="macro-nonterminal">$err </span>{
<a href=#338 id=338 data-nosnippet>338</a> <span class="prelude-val">None </span>=&gt; e,
<a href=#339 id=339 data-nosnippet>339</a> <span class="prelude-val">Some</span>(err) =&gt; OM::Error::combine(err, e, |err, e| err.or(e))
<a href=#340 id=340 data-nosnippet>340</a> });
<a href=#341 id=341 data-nosnippet>341</a> }
<a href=#342 id=342 data-nosnippet>342</a> <span class="prelude-val">Err</span>(e) =&gt; <span class="kw">return </span><span class="prelude-val">Err</span>(e),
<a href=#343 id=343 data-nosnippet>343</a> };
<a href=#344 id=344 data-nosnippet>344</a> }
<a href=#345 id=345 data-nosnippet>345</a> <span class="macro">succ!</span>(<span class="macro-nonterminal">$it</span>, <span class="macro">permutation_trait_inner!</span>(<span class="macro-nonterminal">$self</span>, <span class="macro-nonterminal">$input</span>, <span class="macro-nonterminal">$res</span>, <span class="macro-nonterminal">$err</span>, $(<span class="macro-nonterminal">$item</span>)<span class="kw-2">*</span>));
<a href=#346 id=346 data-nosnippet>346</a> );
<a href=#347 id=347 data-nosnippet>347</a> (<span class="macro-nonterminal">$it</span>:tt, <span class="macro-nonterminal">$self</span>:expr, <span class="macro-nonterminal">$input</span>:ident, <span class="macro-nonterminal">$res</span>:expr, <span class="macro-nonterminal">$err</span>:expr,) =&gt; ();
<a href=#348 id=348 data-nosnippet>348</a>);
<a href=#349 id=349 data-nosnippet>349</a>
<a href=#350 id=350 data-nosnippet>350</a><span class="macro">permutation_trait!</span>(
<a href=#351 id=351 data-nosnippet>351</a> FnA A a
<a href=#352 id=352 data-nosnippet>352</a> FnB B b
<a href=#353 id=353 data-nosnippet>353</a> FnC C c
<a href=#354 id=354 data-nosnippet>354</a> FnD D d
<a href=#355 id=355 data-nosnippet>355</a> FnE E e
<a href=#356 id=356 data-nosnippet>356</a> FnF F f
<a href=#357 id=357 data-nosnippet>357</a> FnG G g
<a href=#358 id=358 data-nosnippet>358</a> FnH H h
<a href=#359 id=359 data-nosnippet>359</a> FnI I i
<a href=#360 id=360 data-nosnippet>360</a> FnJ J j
<a href=#361 id=361 data-nosnippet>361</a> FnK K k
<a href=#362 id=362 data-nosnippet>362</a> FnL L l
<a href=#363 id=363 data-nosnippet>363</a> FnM M m
<a href=#364 id=364 data-nosnippet>364</a> FnN N n
<a href=#365 id=365 data-nosnippet>365</a> FnO O o
<a href=#366 id=366 data-nosnippet>366</a> FnP P p
<a href=#367 id=367 data-nosnippet>367</a> FnQ Q q
<a href=#368 id=368 data-nosnippet>368</a> FnR R r
<a href=#369 id=369 data-nosnippet>369</a> FnS S s
<a href=#370 id=370 data-nosnippet>370</a> FnT T t
<a href=#371 id=371 data-nosnippet>371</a> FnU U u
<a href=#372 id=372 data-nosnippet>372</a>);
</code></pre></div></section></main></body></html>
+567
View File
@@ -0,0 +1,567 @@
<!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 of the Rust file `/home/newkirk/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/nom-8.0.0/src/bytes/complete.rs`."><title>complete.rs - source</title><script>if(window.location.protocol!=="file:")document.head.insertAdjacentHTML("beforeend","SourceSerif4-Regular-6b053e98.ttf.woff2,FiraSans-Italic-81dc35de.woff2,FiraSans-Regular-0fe48ade.woff2,FiraSans-MediumItalic-ccf7e434.woff2,FiraSans-Medium-e1aa3f0a.woff2,SourceCodePro-Regular-8badfe75.ttf.woff2,SourceCodePro-Semibold-aa29a496.ttf.woff2".split(",").map(f=>`<link rel="preload" as="font" type="font/woff2"href="../../../static.files/${f}">`).join(""))</script><link rel="stylesheet" href="../../../static.files/normalize-9960930a.css"><link rel="stylesheet" href="../../../static.files/rustdoc-ca0dd0c4.css"><meta name="rustdoc-vars" data-root-path="../../../" data-static-root-path="../../../static.files/" data-current-crate="nom" data-themes="" data-resource-suffix="" data-rustdoc-version="1.93.1 (01f6ddf75 2026-02-11) (Arch Linux rust 1:1.93.1-1)" data-channel="1.93.1" data-search-js="search-9e2438ea.js" data-stringdex-js="stringdex-a3946164.js" data-settings-js="settings-c38705f0.js" ><script src="../../../static.files/storage-e2aeef58.js"></script><script defer src="../../../static.files/src-script-813739b1.js"></script><script defer src="../../../src-files.js"></script><script defer src="../../../static.files/main-a410ff4d.js"></script><noscript><link rel="stylesheet" href="../../../static.files/noscript-263c88ec.css"></noscript><link rel="alternate icon" type="image/png" href="../../../static.files/favicon-32x32-eab170b8.png"><link rel="icon" type="image/svg+xml" href="../../../static.files/favicon-044be391.svg"></head><body class="rustdoc src"><!--[if lte IE 11]><div class="warning">This old browser is unsupported and will most likely display funky things.</div><![endif]--><nav class="sidebar"><div class="src-sidebar-title"><h2>Files</h2></div></nav><div class="sidebar-resizer" title="Drag to resize sidebar"></div><main><section id="main-content" class="content"><div class="main-heading"><h1><div class="sub-heading">nom/bytes/</div>complete.rs</h1><rustdoc-toolbar></rustdoc-toolbar></div><div class="example-wrap digits-3"><pre class="rust"><code><a href=#1 id=1 data-nosnippet>1</a><span class="doccomment">//! Parsers recognizing bytes streams, complete input version
<a href=#2 id=2 data-nosnippet>2</a>
<a href=#3 id=3 data-nosnippet>3</a></span><span class="kw">use </span>core::marker::PhantomData;
<a href=#4 id=4 data-nosnippet>4</a>
<a href=#5 id=5 data-nosnippet>5</a><span class="kw">use </span><span class="kw">crate</span>::error::ParseError;
<a href=#6 id=6 data-nosnippet>6</a><span class="kw">use </span><span class="kw">crate</span>::internal::{IResult, Parser};
<a href=#7 id=7 data-nosnippet>7</a><span class="kw">use </span><span class="kw">crate</span>::traits::{Compare, FindSubstring, FindToken, ToUsize};
<a href=#8 id=8 data-nosnippet>8</a><span class="kw">use </span><span class="kw">crate</span>::Complete;
<a href=#9 id=9 data-nosnippet>9</a><span class="kw">use </span><span class="kw">crate</span>::Emit;
<a href=#10 id=10 data-nosnippet>10</a><span class="kw">use </span><span class="kw">crate</span>::Input;
<a href=#11 id=11 data-nosnippet>11</a><span class="kw">use </span><span class="kw">crate</span>::OutputM;
<a href=#12 id=12 data-nosnippet>12</a>
<a href=#13 id=13 data-nosnippet>13</a><span class="doccomment">/// Recognizes a pattern
<a href=#14 id=14 data-nosnippet>14</a>///
<a href=#15 id=15 data-nosnippet>15</a>/// The input data will be compared to the tag combinator's argument and will return the part of
<a href=#16 id=16 data-nosnippet>16</a>/// the input that matches the argument
<a href=#17 id=17 data-nosnippet>17</a>///
<a href=#18 id=18 data-nosnippet>18</a>/// It will return `Err(Err::Error((_, ErrorKind::Tag)))` if the input doesn't match the pattern
<a href=#19 id=19 data-nosnippet>19</a>/// # Example
<a href=#20 id=20 data-nosnippet>20</a>/// ```rust
<a href=#21 id=21 data-nosnippet>21</a>/// # use nom::{Err, error::{Error, ErrorKind}, Needed, IResult};
<a href=#22 id=22 data-nosnippet>22</a>/// use nom::bytes::complete::tag;
<a href=#23 id=23 data-nosnippet>23</a>///
<a href=#24 id=24 data-nosnippet>24</a>/// fn parser(s: &amp;str) -&gt; IResult&lt;&amp;str, &amp;str&gt; {
<a href=#25 id=25 data-nosnippet>25</a>/// tag("Hello")(s)
<a href=#26 id=26 data-nosnippet>26</a>/// }
<a href=#27 id=27 data-nosnippet>27</a>///
<a href=#28 id=28 data-nosnippet>28</a>/// assert_eq!(parser("Hello, World!"), Ok((", World!", "Hello")));
<a href=#29 id=29 data-nosnippet>29</a>/// assert_eq!(parser("Something"), Err(Err::Error(Error::new("Something", ErrorKind::Tag))));
<a href=#30 id=30 data-nosnippet>30</a>/// assert_eq!(parser(""), Err(Err::Error(Error::new("", ErrorKind::Tag))));
<a href=#31 id=31 data-nosnippet>31</a>/// ```
<a href=#32 id=32 data-nosnippet>32</a></span><span class="kw">pub fn </span>tag&lt;T, I, Error: ParseError&lt;I&gt;&gt;(tag: T) -&gt; <span class="kw">impl </span>Fn(I) -&gt; IResult&lt;I, I, Error&gt;
<a href=#33 id=33 data-nosnippet>33</a><span class="kw">where
<a href=#34 id=34 data-nosnippet>34</a> </span>I: Input + Compare&lt;T&gt;,
<a href=#35 id=35 data-nosnippet>35</a> T: Input + Clone,
<a href=#36 id=36 data-nosnippet>36</a>{
<a href=#37 id=37 data-nosnippet>37</a> <span class="kw">move </span>|i: I| {
<a href=#38 id=38 data-nosnippet>38</a> <span class="kw">let </span><span class="kw-2">mut </span>parser = <span class="kw">super</span>::Tag {
<a href=#39 id=39 data-nosnippet>39</a> tag: tag.clone(),
<a href=#40 id=40 data-nosnippet>40</a> e: PhantomData,
<a href=#41 id=41 data-nosnippet>41</a> };
<a href=#42 id=42 data-nosnippet>42</a>
<a href=#43 id=43 data-nosnippet>43</a> parser.process::&lt;OutputM&lt;Emit, Emit, Complete&gt;&gt;(i)
<a href=#44 id=44 data-nosnippet>44</a> }
<a href=#45 id=45 data-nosnippet>45</a>}
<a href=#46 id=46 data-nosnippet>46</a>
<a href=#47 id=47 data-nosnippet>47</a><span class="doccomment">/// Recognizes a case insensitive pattern.
<a href=#48 id=48 data-nosnippet>48</a>///
<a href=#49 id=49 data-nosnippet>49</a>/// The input data will be compared to the tag combinator's argument and will return the part of
<a href=#50 id=50 data-nosnippet>50</a>/// the input that matches the argument with no regard to case.
<a href=#51 id=51 data-nosnippet>51</a>///
<a href=#52 id=52 data-nosnippet>52</a>/// It will return `Err(Err::Error((_, ErrorKind::Tag)))` if the input doesn't match the pattern.
<a href=#53 id=53 data-nosnippet>53</a>/// # Example
<a href=#54 id=54 data-nosnippet>54</a>/// ```rust
<a href=#55 id=55 data-nosnippet>55</a>/// # use nom::{Err, error::{Error, ErrorKind}, Needed, IResult};
<a href=#56 id=56 data-nosnippet>56</a>/// use nom::bytes::complete::tag_no_case;
<a href=#57 id=57 data-nosnippet>57</a>///
<a href=#58 id=58 data-nosnippet>58</a>/// fn parser(s: &amp;str) -&gt; IResult&lt;&amp;str, &amp;str&gt; {
<a href=#59 id=59 data-nosnippet>59</a>/// tag_no_case("hello")(s)
<a href=#60 id=60 data-nosnippet>60</a>/// }
<a href=#61 id=61 data-nosnippet>61</a>///
<a href=#62 id=62 data-nosnippet>62</a>/// assert_eq!(parser("Hello, World!"), Ok((", World!", "Hello")));
<a href=#63 id=63 data-nosnippet>63</a>/// assert_eq!(parser("hello, World!"), Ok((", World!", "hello")));
<a href=#64 id=64 data-nosnippet>64</a>/// assert_eq!(parser("HeLlO, World!"), Ok((", World!", "HeLlO")));
<a href=#65 id=65 data-nosnippet>65</a>/// assert_eq!(parser("Something"), Err(Err::Error(Error::new("Something", ErrorKind::Tag))));
<a href=#66 id=66 data-nosnippet>66</a>/// assert_eq!(parser(""), Err(Err::Error(Error::new("", ErrorKind::Tag))));
<a href=#67 id=67 data-nosnippet>67</a>/// ```
<a href=#68 id=68 data-nosnippet>68</a></span><span class="kw">pub fn </span>tag_no_case&lt;T, I, Error: ParseError&lt;I&gt;&gt;(tag: T) -&gt; <span class="kw">impl </span>Fn(I) -&gt; IResult&lt;I, I, Error&gt;
<a href=#69 id=69 data-nosnippet>69</a><span class="kw">where
<a href=#70 id=70 data-nosnippet>70</a> </span>I: Input + Compare&lt;T&gt;,
<a href=#71 id=71 data-nosnippet>71</a> T: Input + Clone,
<a href=#72 id=72 data-nosnippet>72</a>{
<a href=#73 id=73 data-nosnippet>73</a> <span class="kw">move </span>|i: I| {
<a href=#74 id=74 data-nosnippet>74</a> <span class="kw">let </span><span class="kw-2">mut </span>parser = <span class="kw">super</span>::TagNoCase {
<a href=#75 id=75 data-nosnippet>75</a> tag: tag.clone(),
<a href=#76 id=76 data-nosnippet>76</a> e: PhantomData,
<a href=#77 id=77 data-nosnippet>77</a> };
<a href=#78 id=78 data-nosnippet>78</a>
<a href=#79 id=79 data-nosnippet>79</a> parser.process::&lt;OutputM&lt;Emit, Emit, Complete&gt;&gt;(i)
<a href=#80 id=80 data-nosnippet>80</a> }
<a href=#81 id=81 data-nosnippet>81</a>}
<a href=#82 id=82 data-nosnippet>82</a>
<a href=#83 id=83 data-nosnippet>83</a><span class="doccomment">/// Parse till certain characters are met.
<a href=#84 id=84 data-nosnippet>84</a>///
<a href=#85 id=85 data-nosnippet>85</a>/// The parser will return the longest slice till one of the characters of the combinator's argument are met.
<a href=#86 id=86 data-nosnippet>86</a>///
<a href=#87 id=87 data-nosnippet>87</a>/// It doesn't consume the matched character.
<a href=#88 id=88 data-nosnippet>88</a>///
<a href=#89 id=89 data-nosnippet>89</a>/// It will return a `Err::Error(("", ErrorKind::IsNot))` if the pattern wasn't met.
<a href=#90 id=90 data-nosnippet>90</a>/// # Example
<a href=#91 id=91 data-nosnippet>91</a>/// ```rust
<a href=#92 id=92 data-nosnippet>92</a>/// # use nom::{Err, error::{Error, ErrorKind}, Needed, IResult};
<a href=#93 id=93 data-nosnippet>93</a>/// use nom::bytes::complete::is_not;
<a href=#94 id=94 data-nosnippet>94</a>///
<a href=#95 id=95 data-nosnippet>95</a>/// fn not_space(s: &amp;str) -&gt; IResult&lt;&amp;str, &amp;str&gt; {
<a href=#96 id=96 data-nosnippet>96</a>/// is_not(" \t\r\n")(s)
<a href=#97 id=97 data-nosnippet>97</a>/// }
<a href=#98 id=98 data-nosnippet>98</a>///
<a href=#99 id=99 data-nosnippet>99</a>/// assert_eq!(not_space("Hello, World!"), Ok((" World!", "Hello,")));
<a href=#100 id=100 data-nosnippet>100</a>/// assert_eq!(not_space("Sometimes\t"), Ok(("\t", "Sometimes")));
<a href=#101 id=101 data-nosnippet>101</a>/// assert_eq!(not_space("Nospace"), Ok(("", "Nospace")));
<a href=#102 id=102 data-nosnippet>102</a>/// assert_eq!(not_space(""), Err(Err::Error(Error::new("", ErrorKind::IsNot))));
<a href=#103 id=103 data-nosnippet>103</a>/// ```
<a href=#104 id=104 data-nosnippet>104</a></span><span class="kw">pub fn </span>is_not&lt;T, I, Error: ParseError&lt;I&gt;&gt;(arr: T) -&gt; <span class="kw">impl </span>FnMut(I) -&gt; IResult&lt;I, I, Error&gt;
<a href=#105 id=105 data-nosnippet>105</a><span class="kw">where
<a href=#106 id=106 data-nosnippet>106</a> </span>I: Input,
<a href=#107 id=107 data-nosnippet>107</a> T: FindToken&lt;&lt;I <span class="kw">as </span>Input&gt;::Item&gt;,
<a href=#108 id=108 data-nosnippet>108</a>{
<a href=#109 id=109 data-nosnippet>109</a> <span class="kw">let </span><span class="kw-2">mut </span>parser = <span class="kw">super</span>::is_not(arr);
<a href=#110 id=110 data-nosnippet>110</a>
<a href=#111 id=111 data-nosnippet>111</a> <span class="kw">move </span>|i: I| parser.process::&lt;OutputM&lt;Emit, Emit, Complete&gt;&gt;(i)
<a href=#112 id=112 data-nosnippet>112</a>}
<a href=#113 id=113 data-nosnippet>113</a>
<a href=#114 id=114 data-nosnippet>114</a><span class="doccomment">/// Returns the longest slice of the matches the pattern.
<a href=#115 id=115 data-nosnippet>115</a>///
<a href=#116 id=116 data-nosnippet>116</a>/// The parser will return the longest slice consisting of the characters in provided in the
<a href=#117 id=117 data-nosnippet>117</a>/// combinator's argument.
<a href=#118 id=118 data-nosnippet>118</a>///
<a href=#119 id=119 data-nosnippet>119</a>/// It will return a `Err(Err::Error((_, ErrorKind::IsA)))` if the pattern wasn't met.
<a href=#120 id=120 data-nosnippet>120</a>/// # Example
<a href=#121 id=121 data-nosnippet>121</a>/// ```rust
<a href=#122 id=122 data-nosnippet>122</a>/// # use nom::{Err, error::{Error, ErrorKind}, Needed, IResult};
<a href=#123 id=123 data-nosnippet>123</a>/// use nom::bytes::complete::is_a;
<a href=#124 id=124 data-nosnippet>124</a>///
<a href=#125 id=125 data-nosnippet>125</a>/// fn hex(s: &amp;str) -&gt; IResult&lt;&amp;str, &amp;str&gt; {
<a href=#126 id=126 data-nosnippet>126</a>/// is_a("1234567890ABCDEF")(s)
<a href=#127 id=127 data-nosnippet>127</a>/// }
<a href=#128 id=128 data-nosnippet>128</a>///
<a href=#129 id=129 data-nosnippet>129</a>/// assert_eq!(hex("123 and voila"), Ok((" and voila", "123")));
<a href=#130 id=130 data-nosnippet>130</a>/// assert_eq!(hex("DEADBEEF and others"), Ok((" and others", "DEADBEEF")));
<a href=#131 id=131 data-nosnippet>131</a>/// assert_eq!(hex("BADBABEsomething"), Ok(("something", "BADBABE")));
<a href=#132 id=132 data-nosnippet>132</a>/// assert_eq!(hex("D15EA5E"), Ok(("", "D15EA5E")));
<a href=#133 id=133 data-nosnippet>133</a>/// assert_eq!(hex(""), Err(Err::Error(Error::new("", ErrorKind::IsA))));
<a href=#134 id=134 data-nosnippet>134</a>/// ```
<a href=#135 id=135 data-nosnippet>135</a></span><span class="kw">pub fn </span>is_a&lt;T, I, Error: ParseError&lt;I&gt;&gt;(arr: T) -&gt; <span class="kw">impl </span>FnMut(I) -&gt; IResult&lt;I, I, Error&gt;
<a href=#136 id=136 data-nosnippet>136</a><span class="kw">where
<a href=#137 id=137 data-nosnippet>137</a> </span>I: Input,
<a href=#138 id=138 data-nosnippet>138</a> T: FindToken&lt;&lt;I <span class="kw">as </span>Input&gt;::Item&gt;,
<a href=#139 id=139 data-nosnippet>139</a>{
<a href=#140 id=140 data-nosnippet>140</a> <span class="kw">let </span><span class="kw-2">mut </span>parser = <span class="kw">super</span>::is_a(arr);
<a href=#141 id=141 data-nosnippet>141</a>
<a href=#142 id=142 data-nosnippet>142</a> <span class="kw">move </span>|i: I| parser.process::&lt;OutputM&lt;Emit, Emit, Complete&gt;&gt;(i)
<a href=#143 id=143 data-nosnippet>143</a>}
<a href=#144 id=144 data-nosnippet>144</a>
<a href=#145 id=145 data-nosnippet>145</a><span class="doccomment">/// Returns the longest input slice (if any) that matches the predicate.
<a href=#146 id=146 data-nosnippet>146</a>///
<a href=#147 id=147 data-nosnippet>147</a>/// The parser will return the longest slice that matches the given predicate *(a function that
<a href=#148 id=148 data-nosnippet>148</a>/// takes the input and returns a bool)*.
<a href=#149 id=149 data-nosnippet>149</a>/// # Example
<a href=#150 id=150 data-nosnippet>150</a>/// ```rust
<a href=#151 id=151 data-nosnippet>151</a>/// # use nom::{Err, error::ErrorKind, Needed, IResult};
<a href=#152 id=152 data-nosnippet>152</a>/// use nom::bytes::complete::take_while;
<a href=#153 id=153 data-nosnippet>153</a>/// use nom::AsChar;
<a href=#154 id=154 data-nosnippet>154</a>///
<a href=#155 id=155 data-nosnippet>155</a>/// fn alpha(s: &amp;[u8]) -&gt; IResult&lt;&amp;[u8], &amp;[u8]&gt; {
<a href=#156 id=156 data-nosnippet>156</a>/// take_while(AsChar::is_alpha)(s)
<a href=#157 id=157 data-nosnippet>157</a>/// }
<a href=#158 id=158 data-nosnippet>158</a>///
<a href=#159 id=159 data-nosnippet>159</a>/// assert_eq!(alpha(b"latin123"), Ok((&amp;b"123"[..], &amp;b"latin"[..])));
<a href=#160 id=160 data-nosnippet>160</a>/// assert_eq!(alpha(b"12345"), Ok((&amp;b"12345"[..], &amp;b""[..])));
<a href=#161 id=161 data-nosnippet>161</a>/// assert_eq!(alpha(b"latin"), Ok((&amp;b""[..], &amp;b"latin"[..])));
<a href=#162 id=162 data-nosnippet>162</a>/// assert_eq!(alpha(b""), Ok((&amp;b""[..], &amp;b""[..])));
<a href=#163 id=163 data-nosnippet>163</a>/// ```
<a href=#164 id=164 data-nosnippet>164</a></span><span class="kw">pub fn </span>take_while&lt;F, I, Error: ParseError&lt;I&gt;&gt;(cond: F) -&gt; <span class="kw">impl </span>FnMut(I) -&gt; IResult&lt;I, I, Error&gt;
<a href=#165 id=165 data-nosnippet>165</a><span class="kw">where
<a href=#166 id=166 data-nosnippet>166</a> </span>I: Input,
<a href=#167 id=167 data-nosnippet>167</a> F: Fn(&lt;I <span class="kw">as </span>Input&gt;::Item) -&gt; bool,
<a href=#168 id=168 data-nosnippet>168</a>{
<a href=#169 id=169 data-nosnippet>169</a> <span class="kw">let </span><span class="kw-2">mut </span>parser = <span class="kw">super</span>::take_while(cond);
<a href=#170 id=170 data-nosnippet>170</a>
<a href=#171 id=171 data-nosnippet>171</a> <span class="kw">move </span>|i: I| parser.process::&lt;OutputM&lt;Emit, Emit, Complete&gt;&gt;(i)
<a href=#172 id=172 data-nosnippet>172</a>}
<a href=#173 id=173 data-nosnippet>173</a>
<a href=#174 id=174 data-nosnippet>174</a><span class="doccomment">/// Returns the longest (at least 1) input slice that matches the predicate.
<a href=#175 id=175 data-nosnippet>175</a>///
<a href=#176 id=176 data-nosnippet>176</a>/// The parser will return the longest slice that matches the given predicate *(a function that
<a href=#177 id=177 data-nosnippet>177</a>/// takes the input and returns a bool)*.
<a href=#178 id=178 data-nosnippet>178</a>///
<a href=#179 id=179 data-nosnippet>179</a>/// It will return an `Err(Err::Error((_, ErrorKind::TakeWhile1)))` if the pattern wasn't met.
<a href=#180 id=180 data-nosnippet>180</a>/// # Example
<a href=#181 id=181 data-nosnippet>181</a>/// ```rust
<a href=#182 id=182 data-nosnippet>182</a>/// # use nom::{Err, error::{Error, ErrorKind}, Needed, IResult};
<a href=#183 id=183 data-nosnippet>183</a>/// use nom::bytes::complete::take_while1;
<a href=#184 id=184 data-nosnippet>184</a>/// use nom::AsChar;
<a href=#185 id=185 data-nosnippet>185</a>///
<a href=#186 id=186 data-nosnippet>186</a>/// fn alpha(s: &amp;[u8]) -&gt; IResult&lt;&amp;[u8], &amp;[u8]&gt; {
<a href=#187 id=187 data-nosnippet>187</a>/// take_while1(AsChar::is_alpha)(s)
<a href=#188 id=188 data-nosnippet>188</a>/// }
<a href=#189 id=189 data-nosnippet>189</a>///
<a href=#190 id=190 data-nosnippet>190</a>/// assert_eq!(alpha(b"latin123"), Ok((&amp;b"123"[..], &amp;b"latin"[..])));
<a href=#191 id=191 data-nosnippet>191</a>/// assert_eq!(alpha(b"latin"), Ok((&amp;b""[..], &amp;b"latin"[..])));
<a href=#192 id=192 data-nosnippet>192</a>/// assert_eq!(alpha(b"12345"), Err(Err::Error(Error::new(&amp;b"12345"[..], ErrorKind::TakeWhile1))));
<a href=#193 id=193 data-nosnippet>193</a>/// ```
<a href=#194 id=194 data-nosnippet>194</a></span><span class="kw">pub fn </span>take_while1&lt;F, I, Error: ParseError&lt;I&gt;&gt;(cond: F) -&gt; <span class="kw">impl </span>FnMut(I) -&gt; IResult&lt;I, I, Error&gt;
<a href=#195 id=195 data-nosnippet>195</a><span class="kw">where
<a href=#196 id=196 data-nosnippet>196</a> </span>I: Input,
<a href=#197 id=197 data-nosnippet>197</a> F: Fn(&lt;I <span class="kw">as </span>Input&gt;::Item) -&gt; bool,
<a href=#198 id=198 data-nosnippet>198</a>{
<a href=#199 id=199 data-nosnippet>199</a> <span class="kw">let </span><span class="kw-2">mut </span>parser = <span class="kw">super</span>::take_while1(cond);
<a href=#200 id=200 data-nosnippet>200</a>
<a href=#201 id=201 data-nosnippet>201</a> <span class="kw">move </span>|i: I| parser.process::&lt;OutputM&lt;Emit, Emit, Complete&gt;&gt;(i)
<a href=#202 id=202 data-nosnippet>202</a>}
<a href=#203 id=203 data-nosnippet>203</a>
<a href=#204 id=204 data-nosnippet>204</a><span class="doccomment">/// Returns the longest (m &lt;= len &lt;= n) input slice that matches the predicate.
<a href=#205 id=205 data-nosnippet>205</a>///
<a href=#206 id=206 data-nosnippet>206</a>/// The parser will return the longest slice that matches the given predicate *(a function that
<a href=#207 id=207 data-nosnippet>207</a>/// takes the input and returns a bool)*.
<a href=#208 id=208 data-nosnippet>208</a>///
<a href=#209 id=209 data-nosnippet>209</a>/// It will return an `Err::Error((_, ErrorKind::TakeWhileMN))` if the pattern wasn't met or is out
<a href=#210 id=210 data-nosnippet>210</a>/// of range (m &lt;= len &lt;= n).
<a href=#211 id=211 data-nosnippet>211</a>/// # Example
<a href=#212 id=212 data-nosnippet>212</a>/// ```rust
<a href=#213 id=213 data-nosnippet>213</a>/// # use nom::{Err, error::{Error, ErrorKind}, Needed, IResult};
<a href=#214 id=214 data-nosnippet>214</a>/// use nom::bytes::complete::take_while_m_n;
<a href=#215 id=215 data-nosnippet>215</a>/// use nom::AsChar;
<a href=#216 id=216 data-nosnippet>216</a>///
<a href=#217 id=217 data-nosnippet>217</a>/// fn short_alpha(s: &amp;[u8]) -&gt; IResult&lt;&amp;[u8], &amp;[u8]&gt; {
<a href=#218 id=218 data-nosnippet>218</a>/// take_while_m_n(3, 6, AsChar::is_alpha)(s)
<a href=#219 id=219 data-nosnippet>219</a>/// }
<a href=#220 id=220 data-nosnippet>220</a>///
<a href=#221 id=221 data-nosnippet>221</a>/// assert_eq!(short_alpha(b"latin123"), Ok((&amp;b"123"[..], &amp;b"latin"[..])));
<a href=#222 id=222 data-nosnippet>222</a>/// assert_eq!(short_alpha(b"lengthy"), Ok((&amp;b"y"[..], &amp;b"length"[..])));
<a href=#223 id=223 data-nosnippet>223</a>/// assert_eq!(short_alpha(b"latin"), Ok((&amp;b""[..], &amp;b"latin"[..])));
<a href=#224 id=224 data-nosnippet>224</a>/// assert_eq!(short_alpha(b"ed"), Err(Err::Error(Error::new(&amp;b"ed"[..], ErrorKind::TakeWhileMN))));
<a href=#225 id=225 data-nosnippet>225</a>/// assert_eq!(short_alpha(b"12345"), Err(Err::Error(Error::new(&amp;b"12345"[..], ErrorKind::TakeWhileMN))));
<a href=#226 id=226 data-nosnippet>226</a>/// ```
<a href=#227 id=227 data-nosnippet>227</a></span><span class="kw">pub fn </span>take_while_m_n&lt;F, I, Error: ParseError&lt;I&gt;&gt;(
<a href=#228 id=228 data-nosnippet>228</a> m: usize,
<a href=#229 id=229 data-nosnippet>229</a> n: usize,
<a href=#230 id=230 data-nosnippet>230</a> cond: F,
<a href=#231 id=231 data-nosnippet>231</a>) -&gt; <span class="kw">impl </span>FnMut(I) -&gt; IResult&lt;I, I, Error&gt;
<a href=#232 id=232 data-nosnippet>232</a><span class="kw">where
<a href=#233 id=233 data-nosnippet>233</a> </span>I: Input,
<a href=#234 id=234 data-nosnippet>234</a> F: Fn(&lt;I <span class="kw">as </span>Input&gt;::Item) -&gt; bool,
<a href=#235 id=235 data-nosnippet>235</a>{
<a href=#236 id=236 data-nosnippet>236</a> <span class="kw">let </span><span class="kw-2">mut </span>parser = <span class="kw">super</span>::take_while_m_n(m, n, cond);
<a href=#237 id=237 data-nosnippet>237</a>
<a href=#238 id=238 data-nosnippet>238</a> <span class="kw">move </span>|i: I| parser.process::&lt;OutputM&lt;Emit, Emit, Complete&gt;&gt;(i)
<a href=#239 id=239 data-nosnippet>239</a>}
<a href=#240 id=240 data-nosnippet>240</a>
<a href=#241 id=241 data-nosnippet>241</a><span class="doccomment">/// Returns the longest input slice (if any) till a predicate is met.
<a href=#242 id=242 data-nosnippet>242</a>///
<a href=#243 id=243 data-nosnippet>243</a>/// The parser will return the longest slice till the given predicate *(a function that
<a href=#244 id=244 data-nosnippet>244</a>/// takes the input and returns a bool)*.
<a href=#245 id=245 data-nosnippet>245</a>/// # Example
<a href=#246 id=246 data-nosnippet>246</a>/// ```rust
<a href=#247 id=247 data-nosnippet>247</a>/// # use nom::{Err, error::ErrorKind, Needed, IResult};
<a href=#248 id=248 data-nosnippet>248</a>/// use nom::bytes::complete::take_till;
<a href=#249 id=249 data-nosnippet>249</a>///
<a href=#250 id=250 data-nosnippet>250</a>/// fn till_colon(s: &amp;str) -&gt; IResult&lt;&amp;str, &amp;str&gt; {
<a href=#251 id=251 data-nosnippet>251</a>/// take_till(|c| c == ':')(s)
<a href=#252 id=252 data-nosnippet>252</a>/// }
<a href=#253 id=253 data-nosnippet>253</a>///
<a href=#254 id=254 data-nosnippet>254</a>/// assert_eq!(till_colon("latin:123"), Ok((":123", "latin")));
<a href=#255 id=255 data-nosnippet>255</a>/// assert_eq!(till_colon(":empty matched"), Ok((":empty matched", ""))); //allowed
<a href=#256 id=256 data-nosnippet>256</a>/// assert_eq!(till_colon("12345"), Ok(("", "12345")));
<a href=#257 id=257 data-nosnippet>257</a>/// assert_eq!(till_colon(""), Ok(("", "")));
<a href=#258 id=258 data-nosnippet>258</a>/// ```
<a href=#259 id=259 data-nosnippet>259</a></span><span class="attr">#[allow(clippy::redundant_closure)]
<a href=#260 id=260 data-nosnippet>260</a></span><span class="kw">pub fn </span>take_till&lt;F, I, Error: ParseError&lt;I&gt;&gt;(cond: F) -&gt; <span class="kw">impl </span>FnMut(I) -&gt; IResult&lt;I, I, Error&gt;
<a href=#261 id=261 data-nosnippet>261</a><span class="kw">where
<a href=#262 id=262 data-nosnippet>262</a> </span>I: Input,
<a href=#263 id=263 data-nosnippet>263</a> F: Fn(&lt;I <span class="kw">as </span>Input&gt;::Item) -&gt; bool,
<a href=#264 id=264 data-nosnippet>264</a>{
<a href=#265 id=265 data-nosnippet>265</a> <span class="kw">let </span><span class="kw-2">mut </span>parser = <span class="kw">super</span>::take_till(cond);
<a href=#266 id=266 data-nosnippet>266</a>
<a href=#267 id=267 data-nosnippet>267</a> <span class="kw">move </span>|i: I| parser.process::&lt;OutputM&lt;Emit, Emit, Complete&gt;&gt;(i)
<a href=#268 id=268 data-nosnippet>268</a>}
<a href=#269 id=269 data-nosnippet>269</a>
<a href=#270 id=270 data-nosnippet>270</a><span class="doccomment">/// Returns the longest (at least 1) input slice till a predicate is met.
<a href=#271 id=271 data-nosnippet>271</a>///
<a href=#272 id=272 data-nosnippet>272</a>/// The parser will return the longest slice till the given predicate *(a function that
<a href=#273 id=273 data-nosnippet>273</a>/// takes the input and returns a bool)*.
<a href=#274 id=274 data-nosnippet>274</a>///
<a href=#275 id=275 data-nosnippet>275</a>/// It will return `Err(Err::Error((_, ErrorKind::TakeTill1)))` if the input is empty or the
<a href=#276 id=276 data-nosnippet>276</a>/// predicate matches the first input.
<a href=#277 id=277 data-nosnippet>277</a>/// # Example
<a href=#278 id=278 data-nosnippet>278</a>/// ```rust
<a href=#279 id=279 data-nosnippet>279</a>/// # use nom::{Err, error::{Error, ErrorKind}, Needed, IResult};
<a href=#280 id=280 data-nosnippet>280</a>/// use nom::bytes::complete::take_till1;
<a href=#281 id=281 data-nosnippet>281</a>///
<a href=#282 id=282 data-nosnippet>282</a>/// fn till_colon(s: &amp;str) -&gt; IResult&lt;&amp;str, &amp;str&gt; {
<a href=#283 id=283 data-nosnippet>283</a>/// take_till1(|c| c == ':')(s)
<a href=#284 id=284 data-nosnippet>284</a>/// }
<a href=#285 id=285 data-nosnippet>285</a>///
<a href=#286 id=286 data-nosnippet>286</a>/// assert_eq!(till_colon("latin:123"), Ok((":123", "latin")));
<a href=#287 id=287 data-nosnippet>287</a>/// assert_eq!(till_colon(":empty matched"), Err(Err::Error(Error::new(":empty matched", ErrorKind::TakeTill1))));
<a href=#288 id=288 data-nosnippet>288</a>/// assert_eq!(till_colon("12345"), Ok(("", "12345")));
<a href=#289 id=289 data-nosnippet>289</a>/// assert_eq!(till_colon(""), Err(Err::Error(Error::new("", ErrorKind::TakeTill1))));
<a href=#290 id=290 data-nosnippet>290</a>/// ```
<a href=#291 id=291 data-nosnippet>291</a></span><span class="attr">#[allow(clippy::redundant_closure)]
<a href=#292 id=292 data-nosnippet>292</a></span><span class="kw">pub fn </span>take_till1&lt;F, I, Error: ParseError&lt;I&gt;&gt;(cond: F) -&gt; <span class="kw">impl </span>FnMut(I) -&gt; IResult&lt;I, I, Error&gt;
<a href=#293 id=293 data-nosnippet>293</a><span class="kw">where
<a href=#294 id=294 data-nosnippet>294</a> </span>I: Input,
<a href=#295 id=295 data-nosnippet>295</a> F: Fn(&lt;I <span class="kw">as </span>Input&gt;::Item) -&gt; bool,
<a href=#296 id=296 data-nosnippet>296</a>{
<a href=#297 id=297 data-nosnippet>297</a> <span class="kw">let </span><span class="kw-2">mut </span>parser = <span class="kw">super</span>::take_till1(cond);
<a href=#298 id=298 data-nosnippet>298</a>
<a href=#299 id=299 data-nosnippet>299</a> <span class="kw">move </span>|i: I| parser.process::&lt;OutputM&lt;Emit, Emit, Complete&gt;&gt;(i)
<a href=#300 id=300 data-nosnippet>300</a>}
<a href=#301 id=301 data-nosnippet>301</a>
<a href=#302 id=302 data-nosnippet>302</a><span class="doccomment">/// Returns an input slice containing the first N input elements (Input[..N]).
<a href=#303 id=303 data-nosnippet>303</a>///
<a href=#304 id=304 data-nosnippet>304</a>/// It will return `Err(Err::Error((_, ErrorKind::Eof)))` if the input is shorter than the argument.
<a href=#305 id=305 data-nosnippet>305</a>/// # Example
<a href=#306 id=306 data-nosnippet>306</a>/// ```rust
<a href=#307 id=307 data-nosnippet>307</a>/// # use nom::{Err, error::{Error, ErrorKind}, Needed, IResult};
<a href=#308 id=308 data-nosnippet>308</a>/// use nom::bytes::complete::take;
<a href=#309 id=309 data-nosnippet>309</a>///
<a href=#310 id=310 data-nosnippet>310</a>/// fn take6(s: &amp;str) -&gt; IResult&lt;&amp;str, &amp;str&gt; {
<a href=#311 id=311 data-nosnippet>311</a>/// take(6usize)(s)
<a href=#312 id=312 data-nosnippet>312</a>/// }
<a href=#313 id=313 data-nosnippet>313</a>///
<a href=#314 id=314 data-nosnippet>314</a>/// assert_eq!(take6("1234567"), Ok(("7", "123456")));
<a href=#315 id=315 data-nosnippet>315</a>/// assert_eq!(take6("things"), Ok(("", "things")));
<a href=#316 id=316 data-nosnippet>316</a>/// assert_eq!(take6("short"), Err(Err::Error(Error::new("short", ErrorKind::Eof))));
<a href=#317 id=317 data-nosnippet>317</a>/// assert_eq!(take6(""), Err(Err::Error(Error::new("", ErrorKind::Eof))));
<a href=#318 id=318 data-nosnippet>318</a>/// ```
<a href=#319 id=319 data-nosnippet>319</a>///
<a href=#320 id=320 data-nosnippet>320</a>/// The units that are taken will depend on the input type. For example, for a
<a href=#321 id=321 data-nosnippet>321</a>/// `&amp;str` it will take a number of `char`'s, whereas for a `&amp;[u8]` it will
<a href=#322 id=322 data-nosnippet>322</a>/// take that many `u8`'s:
<a href=#323 id=323 data-nosnippet>323</a>///
<a href=#324 id=324 data-nosnippet>324</a>/// ```rust
<a href=#325 id=325 data-nosnippet>325</a>/// use nom::error::Error;
<a href=#326 id=326 data-nosnippet>326</a>/// use nom::bytes::complete::take;
<a href=#327 id=327 data-nosnippet>327</a>///
<a href=#328 id=328 data-nosnippet>328</a>/// assert_eq!(take::&lt;_, _, Error&lt;_&gt;&gt;(1usize)("💙"), Ok(("", "💙")));
<a href=#329 id=329 data-nosnippet>329</a>/// assert_eq!(take::&lt;_, _, Error&lt;_&gt;&gt;(1usize)("💙".as_bytes()), Ok((b"\x9F\x92\x99".as_ref(), b"\xF0".as_ref())));
<a href=#330 id=330 data-nosnippet>330</a>/// ```
<a href=#331 id=331 data-nosnippet>331</a></span><span class="kw">pub fn </span>take&lt;C, I, Error: ParseError&lt;I&gt;&gt;(count: C) -&gt; <span class="kw">impl </span>FnMut(I) -&gt; IResult&lt;I, I, Error&gt;
<a href=#332 id=332 data-nosnippet>332</a><span class="kw">where
<a href=#333 id=333 data-nosnippet>333</a> </span>I: Input,
<a href=#334 id=334 data-nosnippet>334</a> C: ToUsize,
<a href=#335 id=335 data-nosnippet>335</a>{
<a href=#336 id=336 data-nosnippet>336</a> <span class="kw">let </span><span class="kw-2">mut </span>parser = <span class="kw">super</span>::take(count);
<a href=#337 id=337 data-nosnippet>337</a>
<a href=#338 id=338 data-nosnippet>338</a> <span class="kw">move </span>|i: I| parser.process::&lt;OutputM&lt;Emit, Emit, Complete&gt;&gt;(i)
<a href=#339 id=339 data-nosnippet>339</a>}
<a href=#340 id=340 data-nosnippet>340</a>
<a href=#341 id=341 data-nosnippet>341</a><span class="doccomment">/// Returns the input slice up to the first occurrence of the pattern.
<a href=#342 id=342 data-nosnippet>342</a>///
<a href=#343 id=343 data-nosnippet>343</a>/// It doesn't consume the pattern. It will return `Err(Err::Error((_, ErrorKind::TakeUntil)))`
<a href=#344 id=344 data-nosnippet>344</a>/// if the pattern wasn't met.
<a href=#345 id=345 data-nosnippet>345</a>/// # Example
<a href=#346 id=346 data-nosnippet>346</a>/// ```rust
<a href=#347 id=347 data-nosnippet>347</a>/// # use nom::{Err, error::{Error, ErrorKind}, Needed, IResult};
<a href=#348 id=348 data-nosnippet>348</a>/// use nom::bytes::complete::take_until;
<a href=#349 id=349 data-nosnippet>349</a>///
<a href=#350 id=350 data-nosnippet>350</a>/// fn until_eof(s: &amp;str) -&gt; IResult&lt;&amp;str, &amp;str&gt; {
<a href=#351 id=351 data-nosnippet>351</a>/// take_until("eof")(s)
<a href=#352 id=352 data-nosnippet>352</a>/// }
<a href=#353 id=353 data-nosnippet>353</a>///
<a href=#354 id=354 data-nosnippet>354</a>/// assert_eq!(until_eof("hello, worldeof"), Ok(("eof", "hello, world")));
<a href=#355 id=355 data-nosnippet>355</a>/// assert_eq!(until_eof("hello, world"), Err(Err::Error(Error::new("hello, world", ErrorKind::TakeUntil))));
<a href=#356 id=356 data-nosnippet>356</a>/// assert_eq!(until_eof(""), Err(Err::Error(Error::new("", ErrorKind::TakeUntil))));
<a href=#357 id=357 data-nosnippet>357</a>/// assert_eq!(until_eof("1eof2eof"), Ok(("eof2eof", "1")));
<a href=#358 id=358 data-nosnippet>358</a>/// ```
<a href=#359 id=359 data-nosnippet>359</a></span><span class="kw">pub fn </span>take_until&lt;T, I, Error: ParseError&lt;I&gt;&gt;(tag: T) -&gt; <span class="kw">impl </span>FnMut(I) -&gt; IResult&lt;I, I, Error&gt;
<a href=#360 id=360 data-nosnippet>360</a><span class="kw">where
<a href=#361 id=361 data-nosnippet>361</a> </span>I: Input + FindSubstring&lt;T&gt;,
<a href=#362 id=362 data-nosnippet>362</a> T: Input + Clone,
<a href=#363 id=363 data-nosnippet>363</a>{
<a href=#364 id=364 data-nosnippet>364</a> <span class="kw">let </span><span class="kw-2">mut </span>parser = <span class="kw">super</span>::take_until(tag);
<a href=#365 id=365 data-nosnippet>365</a>
<a href=#366 id=366 data-nosnippet>366</a> <span class="kw">move </span>|i: I| parser.process::&lt;OutputM&lt;Emit, Emit, Complete&gt;&gt;(i)
<a href=#367 id=367 data-nosnippet>367</a>}
<a href=#368 id=368 data-nosnippet>368</a>
<a href=#369 id=369 data-nosnippet>369</a><span class="doccomment">/// Returns the non empty input slice up to the first occurrence of the pattern.
<a href=#370 id=370 data-nosnippet>370</a>///
<a href=#371 id=371 data-nosnippet>371</a>/// It doesn't consume the pattern. It will return `Err(Err::Error((_, ErrorKind::TakeUntil)))`
<a href=#372 id=372 data-nosnippet>372</a>/// if the pattern wasn't met.
<a href=#373 id=373 data-nosnippet>373</a>/// # Example
<a href=#374 id=374 data-nosnippet>374</a>/// ```rust
<a href=#375 id=375 data-nosnippet>375</a>/// # use nom::{Err, error::{Error, ErrorKind}, Needed, IResult};
<a href=#376 id=376 data-nosnippet>376</a>/// use nom::bytes::complete::take_until1;
<a href=#377 id=377 data-nosnippet>377</a>///
<a href=#378 id=378 data-nosnippet>378</a>/// fn until_eof(s: &amp;str) -&gt; IResult&lt;&amp;str, &amp;str&gt; {
<a href=#379 id=379 data-nosnippet>379</a>/// take_until1("eof")(s)
<a href=#380 id=380 data-nosnippet>380</a>/// }
<a href=#381 id=381 data-nosnippet>381</a>///
<a href=#382 id=382 data-nosnippet>382</a>/// assert_eq!(until_eof("hello, worldeof"), Ok(("eof", "hello, world")));
<a href=#383 id=383 data-nosnippet>383</a>/// assert_eq!(until_eof("hello, world"), Err(Err::Error(Error::new("hello, world", ErrorKind::TakeUntil))));
<a href=#384 id=384 data-nosnippet>384</a>/// assert_eq!(until_eof(""), Err(Err::Error(Error::new("", ErrorKind::TakeUntil))));
<a href=#385 id=385 data-nosnippet>385</a>/// assert_eq!(until_eof("1eof2eof"), Ok(("eof2eof", "1")));
<a href=#386 id=386 data-nosnippet>386</a>/// assert_eq!(until_eof("eof"), Err(Err::Error(Error::new("eof", ErrorKind::TakeUntil))));
<a href=#387 id=387 data-nosnippet>387</a>/// ```
<a href=#388 id=388 data-nosnippet>388</a></span><span class="kw">pub fn </span>take_until1&lt;T, I, Error: ParseError&lt;I&gt;&gt;(tag: T) -&gt; <span class="kw">impl </span>FnMut(I) -&gt; IResult&lt;I, I, Error&gt;
<a href=#389 id=389 data-nosnippet>389</a><span class="kw">where
<a href=#390 id=390 data-nosnippet>390</a> </span>I: Input + FindSubstring&lt;T&gt;,
<a href=#391 id=391 data-nosnippet>391</a> T: Input + Clone,
<a href=#392 id=392 data-nosnippet>392</a>{
<a href=#393 id=393 data-nosnippet>393</a> <span class="kw">let </span><span class="kw-2">mut </span>parser = <span class="kw">super</span>::take_until1(tag);
<a href=#394 id=394 data-nosnippet>394</a>
<a href=#395 id=395 data-nosnippet>395</a> <span class="kw">move </span>|i: I| parser.process::&lt;OutputM&lt;Emit, Emit, Complete&gt;&gt;(i)
<a href=#396 id=396 data-nosnippet>396</a>}
<a href=#397 id=397 data-nosnippet>397</a>
<a href=#398 id=398 data-nosnippet>398</a><span class="doccomment">/// Matches a byte string with escaped characters.
<a href=#399 id=399 data-nosnippet>399</a>///
<a href=#400 id=400 data-nosnippet>400</a>/// * The first argument matches the normal characters (it must not accept the control character)
<a href=#401 id=401 data-nosnippet>401</a>/// * The second argument is the control character (like `\` in most languages)
<a href=#402 id=402 data-nosnippet>402</a>/// * The third argument matches the escaped characters
<a href=#403 id=403 data-nosnippet>403</a>/// # Example
<a href=#404 id=404 data-nosnippet>404</a>/// ```
<a href=#405 id=405 data-nosnippet>405</a>/// # use nom::{Err, error::ErrorKind, Needed, IResult};
<a href=#406 id=406 data-nosnippet>406</a>/// # use nom::character::complete::digit1;
<a href=#407 id=407 data-nosnippet>407</a>/// use nom::bytes::complete::escaped;
<a href=#408 id=408 data-nosnippet>408</a>/// use nom::character::complete::one_of;
<a href=#409 id=409 data-nosnippet>409</a>///
<a href=#410 id=410 data-nosnippet>410</a>/// fn esc(s: &amp;str) -&gt; IResult&lt;&amp;str, &amp;str&gt; {
<a href=#411 id=411 data-nosnippet>411</a>/// escaped(digit1, '\\', one_of(r#""n\"#))(s)
<a href=#412 id=412 data-nosnippet>412</a>/// }
<a href=#413 id=413 data-nosnippet>413</a>///
<a href=#414 id=414 data-nosnippet>414</a>/// assert_eq!(esc("123;"), Ok((";", "123")));
<a href=#415 id=415 data-nosnippet>415</a>/// assert_eq!(esc(r#"12\"34;"#), Ok((";", r#"12\"34"#)));
<a href=#416 id=416 data-nosnippet>416</a>/// ```
<a href=#417 id=417 data-nosnippet>417</a>///
<a href=#418 id=418 data-nosnippet>418</a></span><span class="kw">pub fn </span>escaped&lt;<span class="lifetime">'a</span>, I, Error, F, G&gt;(
<a href=#419 id=419 data-nosnippet>419</a> normal: F,
<a href=#420 id=420 data-nosnippet>420</a> control_char: char,
<a href=#421 id=421 data-nosnippet>421</a> escapable: G,
<a href=#422 id=422 data-nosnippet>422</a>) -&gt; <span class="kw">impl </span>FnMut(I) -&gt; IResult&lt;I, I, Error&gt;
<a href=#423 id=423 data-nosnippet>423</a><span class="kw">where
<a href=#424 id=424 data-nosnippet>424</a> </span>I: Clone + <span class="kw">crate</span>::traits::Offset + Input + <span class="lifetime">'a</span>,
<a href=#425 id=425 data-nosnippet>425</a> &lt;I <span class="kw">as </span>Input&gt;::Item: <span class="kw">crate</span>::traits::AsChar,
<a href=#426 id=426 data-nosnippet>426</a> F: Parser&lt;I, Error = Error&gt;,
<a href=#427 id=427 data-nosnippet>427</a> G: Parser&lt;I, Error = Error&gt;,
<a href=#428 id=428 data-nosnippet>428</a> Error: ParseError&lt;I&gt;,
<a href=#429 id=429 data-nosnippet>429</a>{
<a href=#430 id=430 data-nosnippet>430</a> <span class="kw">let </span><span class="kw-2">mut </span>parser = <span class="kw">super</span>::escaped(normal, control_char, escapable);
<a href=#431 id=431 data-nosnippet>431</a>
<a href=#432 id=432 data-nosnippet>432</a> <span class="kw">move </span>|i: I| parser.process::&lt;OutputM&lt;Emit, Emit, Complete&gt;&gt;(i)
<a href=#433 id=433 data-nosnippet>433</a>}
<a href=#434 id=434 data-nosnippet>434</a>
<a href=#435 id=435 data-nosnippet>435</a><span class="doccomment">/// Matches a byte string with escaped characters.
<a href=#436 id=436 data-nosnippet>436</a>///
<a href=#437 id=437 data-nosnippet>437</a>/// * The first argument matches the normal characters (it must not match the control character)
<a href=#438 id=438 data-nosnippet>438</a>/// * The second argument is the control character (like `\` in most languages)
<a href=#439 id=439 data-nosnippet>439</a>/// * The third argument matches the escaped characters and transforms them
<a href=#440 id=440 data-nosnippet>440</a>///
<a href=#441 id=441 data-nosnippet>441</a>/// As an example, the chain `abc\tdef` could be `abc def` (it also consumes the control character)
<a href=#442 id=442 data-nosnippet>442</a>///
<a href=#443 id=443 data-nosnippet>443</a>/// ```
<a href=#444 id=444 data-nosnippet>444</a>/// # use nom::{Err, error::ErrorKind, Needed, IResult};
<a href=#445 id=445 data-nosnippet>445</a>/// # use std::str::from_utf8;
<a href=#446 id=446 data-nosnippet>446</a>/// use nom::bytes::complete::{escaped_transform, tag};
<a href=#447 id=447 data-nosnippet>447</a>/// use nom::character::complete::alpha1;
<a href=#448 id=448 data-nosnippet>448</a>/// use nom::branch::alt;
<a href=#449 id=449 data-nosnippet>449</a>/// use nom::combinator::value;
<a href=#450 id=450 data-nosnippet>450</a>///
<a href=#451 id=451 data-nosnippet>451</a>/// fn parser(input: &amp;str) -&gt; IResult&lt;&amp;str, String&gt; {
<a href=#452 id=452 data-nosnippet>452</a>/// escaped_transform(
<a href=#453 id=453 data-nosnippet>453</a>/// alpha1,
<a href=#454 id=454 data-nosnippet>454</a>/// '\\',
<a href=#455 id=455 data-nosnippet>455</a>/// alt((
<a href=#456 id=456 data-nosnippet>456</a>/// value("\\", tag("\\")),
<a href=#457 id=457 data-nosnippet>457</a>/// value("\"", tag("\"")),
<a href=#458 id=458 data-nosnippet>458</a>/// value("\n", tag("n")),
<a href=#459 id=459 data-nosnippet>459</a>/// ))
<a href=#460 id=460 data-nosnippet>460</a>/// )(input)
<a href=#461 id=461 data-nosnippet>461</a>/// }
<a href=#462 id=462 data-nosnippet>462</a>///
<a href=#463 id=463 data-nosnippet>463</a>/// assert_eq!(parser("ab\\\"cd"), Ok(("", String::from("ab\"cd"))));
<a href=#464 id=464 data-nosnippet>464</a>/// assert_eq!(parser("ab\\ncd"), Ok(("", String::from("ab\ncd"))));
<a href=#465 id=465 data-nosnippet>465</a>/// ```
<a href=#466 id=466 data-nosnippet>466</a></span><span class="attr">#[cfg(feature = <span class="string">"alloc"</span>)]
<a href=#467 id=467 data-nosnippet>467</a>#[cfg_attr(feature = <span class="string">"docsrs"</span>, doc(cfg(feature = <span class="string">"alloc"</span>)))]
<a href=#468 id=468 data-nosnippet>468</a></span><span class="kw">pub fn </span>escaped_transform&lt;I, Error, F, G, O1, O2, ExtendItem, Output&gt;(
<a href=#469 id=469 data-nosnippet>469</a> normal: F,
<a href=#470 id=470 data-nosnippet>470</a> control_char: char,
<a href=#471 id=471 data-nosnippet>471</a> transform: G,
<a href=#472 id=472 data-nosnippet>472</a>) -&gt; <span class="kw">impl </span>FnMut(I) -&gt; IResult&lt;I, Output, Error&gt;
<a href=#473 id=473 data-nosnippet>473</a><span class="kw">where
<a href=#474 id=474 data-nosnippet>474</a> </span>I: Clone + <span class="kw">crate</span>::traits::Offset + Input,
<a href=#475 id=475 data-nosnippet>475</a> I: <span class="kw">crate</span>::traits::ExtendInto&lt;Item = ExtendItem, Extender = Output&gt;,
<a href=#476 id=476 data-nosnippet>476</a> O1: <span class="kw">crate</span>::traits::ExtendInto&lt;Item = ExtendItem, Extender = Output&gt;,
<a href=#477 id=477 data-nosnippet>477</a> O2: <span class="kw">crate</span>::traits::ExtendInto&lt;Item = ExtendItem, Extender = Output&gt;,
<a href=#478 id=478 data-nosnippet>478</a> &lt;I <span class="kw">as </span>Input&gt;::Item: <span class="kw">crate</span>::traits::AsChar,
<a href=#479 id=479 data-nosnippet>479</a> F: Parser&lt;I, Output = O1, Error = Error&gt;,
<a href=#480 id=480 data-nosnippet>480</a> G: Parser&lt;I, Output = O2, Error = Error&gt;,
<a href=#481 id=481 data-nosnippet>481</a> Error: ParseError&lt;I&gt;,
<a href=#482 id=482 data-nosnippet>482</a>{
<a href=#483 id=483 data-nosnippet>483</a> <span class="kw">let </span><span class="kw-2">mut </span>parser = <span class="kw">super</span>::escaped_transform(normal, control_char, transform);
<a href=#484 id=484 data-nosnippet>484</a>
<a href=#485 id=485 data-nosnippet>485</a> <span class="kw">move </span>|i: I| parser.process::&lt;OutputM&lt;Emit, Emit, Complete&gt;&gt;(i)
<a href=#486 id=486 data-nosnippet>486</a>}
<a href=#487 id=487 data-nosnippet>487</a>
<a href=#488 id=488 data-nosnippet>488</a><span class="attr">#[cfg(test)]
<a href=#489 id=489 data-nosnippet>489</a></span><span class="kw">mod </span>tests {
<a href=#490 id=490 data-nosnippet>490</a> <span class="kw">use super</span>::<span class="kw-2">*</span>;
<a href=#491 id=491 data-nosnippet>491</a> <span class="kw">use </span><span class="kw">crate</span>::error::ErrorKind;
<a href=#492 id=492 data-nosnippet>492</a> <span class="kw">use </span><span class="kw">crate</span>::AsChar;
<a href=#493 id=493 data-nosnippet>493</a> <span class="kw">use </span><span class="kw">crate</span>::Err;
<a href=#494 id=494 data-nosnippet>494</a>
<a href=#495 id=495 data-nosnippet>495</a> <span class="attr">#[test]
<a href=#496 id=496 data-nosnippet>496</a> </span><span class="kw">fn </span>complete_take_while_m_n_utf8_all_matching() {
<a href=#497 id=497 data-nosnippet>497</a> <span class="kw">let </span>result: IResult&lt;<span class="kw-2">&amp;</span>str, <span class="kw-2">&amp;</span>str&gt; =
<a href=#498 id=498 data-nosnippet>498</a> <span class="kw">super</span>::take_while_m_n(<span class="number">1</span>, <span class="number">4</span>, |c: char| c.is_alphabetic())(<span class="string">"øn"</span>);
<a href=#499 id=499 data-nosnippet>499</a> <span class="macro">assert_eq!</span>(result, <span class="prelude-val">Ok</span>((<span class="string">""</span>, <span class="string">"øn"</span>)));
<a href=#500 id=500 data-nosnippet>500</a> }
<a href=#501 id=501 data-nosnippet>501</a>
<a href=#502 id=502 data-nosnippet>502</a> <span class="attr">#[test]
<a href=#503 id=503 data-nosnippet>503</a> </span><span class="kw">fn </span>complete_take_while_m_n_utf8_all_matching_substring() {
<a href=#504 id=504 data-nosnippet>504</a> <span class="kw">let </span>result: IResult&lt;<span class="kw-2">&amp;</span>str, <span class="kw-2">&amp;</span>str&gt; =
<a href=#505 id=505 data-nosnippet>505</a> <span class="kw">super</span>::take_while_m_n(<span class="number">1</span>, <span class="number">1</span>, |c: char| c.is_alphabetic())(<span class="string">"øn"</span>);
<a href=#506 id=506 data-nosnippet>506</a> <span class="macro">assert_eq!</span>(result, <span class="prelude-val">Ok</span>((<span class="string">"n"</span>, <span class="string">"ø"</span>)));
<a href=#507 id=507 data-nosnippet>507</a> }
<a href=#508 id=508 data-nosnippet>508</a>
<a href=#509 id=509 data-nosnippet>509</a> <span class="comment">// issue #1336 "escaped hangs if normal parser accepts empty"
<a href=#510 id=510 data-nosnippet>510</a> </span><span class="kw">fn </span>escaped_string(input: <span class="kw-2">&amp;</span>str) -&gt; IResult&lt;<span class="kw-2">&amp;</span>str, <span class="kw-2">&amp;</span>str&gt; {
<a href=#511 id=511 data-nosnippet>511</a> <span class="kw">use </span><span class="kw">crate</span>::character::complete::{alpha0, one_of};
<a href=#512 id=512 data-nosnippet>512</a> escaped(alpha0, <span class="string">'\\'</span>, one_of(<span class="string">"n"</span>))(input)
<a href=#513 id=513 data-nosnippet>513</a> }
<a href=#514 id=514 data-nosnippet>514</a>
<a href=#515 id=515 data-nosnippet>515</a> <span class="comment">// issue #1336 "escaped hangs if normal parser accepts empty"
<a href=#516 id=516 data-nosnippet>516</a> </span><span class="attr">#[test]
<a href=#517 id=517 data-nosnippet>517</a> </span><span class="kw">fn </span>escaped_hang() {
<a href=#518 id=518 data-nosnippet>518</a> escaped_string(<span class="string">"7"</span>).unwrap();
<a href=#519 id=519 data-nosnippet>519</a> escaped_string(<span class="string">"a7"</span>).unwrap();
<a href=#520 id=520 data-nosnippet>520</a> }
<a href=#521 id=521 data-nosnippet>521</a>
<a href=#522 id=522 data-nosnippet>522</a> <span class="comment">// issue ##1118 escaped does not work with empty string
<a href=#523 id=523 data-nosnippet>523</a> </span><span class="kw">fn </span>unquote(input: <span class="kw-2">&amp;</span>str) -&gt; IResult&lt;<span class="kw-2">&amp;</span>str, <span class="kw-2">&amp;</span>str&gt; {
<a href=#524 id=524 data-nosnippet>524</a> <span class="kw">use </span><span class="kw">crate</span>::bytes::complete::<span class="kw-2">*</span>;
<a href=#525 id=525 data-nosnippet>525</a> <span class="kw">use </span><span class="kw">crate</span>::character::complete::<span class="kw-2">*</span>;
<a href=#526 id=526 data-nosnippet>526</a> <span class="kw">use </span><span class="kw">crate</span>::combinator::opt;
<a href=#527 id=527 data-nosnippet>527</a> <span class="kw">use </span><span class="kw">crate</span>::sequence::delimited;
<a href=#528 id=528 data-nosnippet>528</a>
<a href=#529 id=529 data-nosnippet>529</a> delimited(
<a href=#530 id=530 data-nosnippet>530</a> char(<span class="string">'"'</span>),
<a href=#531 id=531 data-nosnippet>531</a> escaped(opt(none_of(<span class="string">r#"\""#</span>)), <span class="string">'\\'</span>, one_of(<span class="string">r#"\"rnt"#</span>)),
<a href=#532 id=532 data-nosnippet>532</a> char(<span class="string">'"'</span>),
<a href=#533 id=533 data-nosnippet>533</a> )
<a href=#534 id=534 data-nosnippet>534</a> .parse(input)
<a href=#535 id=535 data-nosnippet>535</a> }
<a href=#536 id=536 data-nosnippet>536</a>
<a href=#537 id=537 data-nosnippet>537</a> <span class="attr">#[test]
<a href=#538 id=538 data-nosnippet>538</a> </span><span class="kw">fn </span>escaped_hang_1118() {
<a href=#539 id=539 data-nosnippet>539</a> <span class="macro">assert_eq!</span>(unquote(<span class="string">r#""""#</span>), <span class="prelude-val">Ok</span>((<span class="string">""</span>, <span class="string">""</span>)));
<a href=#540 id=540 data-nosnippet>540</a> }
<a href=#541 id=541 data-nosnippet>541</a>
<a href=#542 id=542 data-nosnippet>542</a> <span class="comment">// issue #1630 take_while_m_n is invalid for multi-byte UTF-8 characters
<a href=#543 id=543 data-nosnippet>543</a> </span><span class="attr">#[test]
<a href=#544 id=544 data-nosnippet>544</a> </span><span class="kw">fn </span>complete_take_while_m_n_multibyte() {
<a href=#545 id=545 data-nosnippet>545</a> <span class="kw">use </span><span class="kw">crate</span>::error::Error;
<a href=#546 id=546 data-nosnippet>546</a>
<a href=#547 id=547 data-nosnippet>547</a> <span class="kw">fn </span>multi_byte_chars(s: <span class="kw-2">&amp;</span>str, m: usize, n: usize) -&gt; IResult&lt;<span class="kw-2">&amp;</span>str, <span class="kw-2">&amp;</span>str&gt; {
<a href=#548 id=548 data-nosnippet>548</a> take_while_m_n(m, n, |c: char| c.len() &gt; <span class="number">1</span>)(s)
<a href=#549 id=549 data-nosnippet>549</a> }
<a href=#550 id=550 data-nosnippet>550</a>
<a href=#551 id=551 data-nosnippet>551</a> <span class="macro">assert_eq!</span>(multi_byte_chars(<span class="string">"€ latin"</span>, <span class="number">0</span>, <span class="number">64</span>), <span class="prelude-val">Ok</span>((<span class="string">" latin"</span>, <span class="string">"€"</span>)));
<a href=#552 id=552 data-nosnippet>552</a> <span class="macro">assert_eq!</span>(multi_byte_chars(<span class="string">"𝄠 latin"</span>, <span class="number">0</span>, <span class="number">1</span>), <span class="prelude-val">Ok</span>((<span class="string">" latin"</span>, <span class="string">"𝄠"</span>)));
<a href=#553 id=553 data-nosnippet>553</a> <span class="macro">assert_eq!</span>(multi_byte_chars(<span class="string">"باب latin"</span>, <span class="number">0</span>, <span class="number">64</span>), <span class="prelude-val">Ok</span>((<span class="string">" latin"</span>, <span class="string">"باب"</span>)));
<a href=#554 id=554 data-nosnippet>554</a> <span class="macro">assert_eq!</span>(
<a href=#555 id=555 data-nosnippet>555</a> multi_byte_chars(<span class="string">"💣💢ᾠ latin"</span>, <span class="number">3</span>, <span class="number">3</span>),
<a href=#556 id=556 data-nosnippet>556</a> <span class="prelude-val">Ok</span>((<span class="string">" latin"</span>, <span class="string">"💣💢ᾠ"</span>))
<a href=#557 id=557 data-nosnippet>557</a> );
<a href=#558 id=558 data-nosnippet>558</a> <span class="macro">assert_eq!</span>(multi_byte_chars(<span class="string">"latin"</span>, <span class="number">0</span>, <span class="number">64</span>), <span class="prelude-val">Ok</span>((<span class="string">"latin"</span>, <span class="string">""</span>)));
<a href=#559 id=559 data-nosnippet>559</a> <span class="macro">assert_eq!</span>(multi_byte_chars(<span class="string">"باب"</span>, <span class="number">1</span>, <span class="number">3</span>), <span class="prelude-val">Ok</span>((<span class="string">""</span>, <span class="string">"باب"</span>)));
<a href=#560 id=560 data-nosnippet>560</a> <span class="macro">assert_eq!</span>(multi_byte_chars(<span class="string">"باب"</span>, <span class="number">1</span>, <span class="number">2</span>), <span class="prelude-val">Ok</span>((<span class="string">"ب"</span>, <span class="string">"با"</span>)));
<a href=#561 id=561 data-nosnippet>561</a> <span class="macro">assert_eq!</span>(
<a href=#562 id=562 data-nosnippet>562</a> multi_byte_chars(<span class="string">"latin"</span>, <span class="number">1</span>, <span class="number">64</span>),
<a href=#563 id=563 data-nosnippet>563</a> <span class="prelude-val">Err</span>(Err::Error(Error::new(<span class="string">"latin"</span>, ErrorKind::TakeWhileMN)))
<a href=#564 id=564 data-nosnippet>564</a> );
<a href=#565 id=565 data-nosnippet>565</a> }
<a href=#566 id=566 data-nosnippet>566</a>}
</code></pre></div></section></main></body></html>
File diff suppressed because it is too large Load Diff
+500
View File
@@ -0,0 +1,500 @@
<!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 of the Rust file `/home/newkirk/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/nom-8.0.0/src/bytes/streaming.rs`."><title>streaming.rs - source</title><script>if(window.location.protocol!=="file:")document.head.insertAdjacentHTML("beforeend","SourceSerif4-Regular-6b053e98.ttf.woff2,FiraSans-Italic-81dc35de.woff2,FiraSans-Regular-0fe48ade.woff2,FiraSans-MediumItalic-ccf7e434.woff2,FiraSans-Medium-e1aa3f0a.woff2,SourceCodePro-Regular-8badfe75.ttf.woff2,SourceCodePro-Semibold-aa29a496.ttf.woff2".split(",").map(f=>`<link rel="preload" as="font" type="font/woff2"href="../../../static.files/${f}">`).join(""))</script><link rel="stylesheet" href="../../../static.files/normalize-9960930a.css"><link rel="stylesheet" href="../../../static.files/rustdoc-ca0dd0c4.css"><meta name="rustdoc-vars" data-root-path="../../../" data-static-root-path="../../../static.files/" data-current-crate="nom" data-themes="" data-resource-suffix="" data-rustdoc-version="1.93.1 (01f6ddf75 2026-02-11) (Arch Linux rust 1:1.93.1-1)" data-channel="1.93.1" data-search-js="search-9e2438ea.js" data-stringdex-js="stringdex-a3946164.js" data-settings-js="settings-c38705f0.js" ><script src="../../../static.files/storage-e2aeef58.js"></script><script defer src="../../../static.files/src-script-813739b1.js"></script><script defer src="../../../src-files.js"></script><script defer src="../../../static.files/main-a410ff4d.js"></script><noscript><link rel="stylesheet" href="../../../static.files/noscript-263c88ec.css"></noscript><link rel="alternate icon" type="image/png" href="../../../static.files/favicon-32x32-eab170b8.png"><link rel="icon" type="image/svg+xml" href="../../../static.files/favicon-044be391.svg"></head><body class="rustdoc src"><!--[if lte IE 11]><div class="warning">This old browser is unsupported and will most likely display funky things.</div><![endif]--><nav class="sidebar"><div class="src-sidebar-title"><h2>Files</h2></div></nav><div class="sidebar-resizer" title="Drag to resize sidebar"></div><main><section id="main-content" class="content"><div class="main-heading"><h1><div class="sub-heading">nom/bytes/</div>streaming.rs</h1><rustdoc-toolbar></rustdoc-toolbar></div><div class="example-wrap digits-3"><pre class="rust"><code><a href=#1 id=1 data-nosnippet>1</a><span class="doccomment">//! Parsers recognizing bytes streams, streaming version
<a href=#2 id=2 data-nosnippet>2</a>
<a href=#3 id=3 data-nosnippet>3</a></span><span class="kw">use </span>core::marker::PhantomData;
<a href=#4 id=4 data-nosnippet>4</a>
<a href=#5 id=5 data-nosnippet>5</a><span class="kw">use </span><span class="kw">crate</span>::error::ParseError;
<a href=#6 id=6 data-nosnippet>6</a><span class="kw">use </span><span class="kw">crate</span>::internal::{IResult, Parser};
<a href=#7 id=7 data-nosnippet>7</a><span class="kw">use </span><span class="kw">crate</span>::traits::{Compare, FindSubstring, FindToken, ToUsize};
<a href=#8 id=8 data-nosnippet>8</a><span class="kw">use </span><span class="kw">crate</span>::Emit;
<a href=#9 id=9 data-nosnippet>9</a><span class="kw">use </span><span class="kw">crate</span>::Input;
<a href=#10 id=10 data-nosnippet>10</a><span class="kw">use </span><span class="kw">crate</span>::OutputM;
<a href=#11 id=11 data-nosnippet>11</a><span class="kw">use </span><span class="kw">crate</span>::Streaming;
<a href=#12 id=12 data-nosnippet>12</a>
<a href=#13 id=13 data-nosnippet>13</a><span class="doccomment">/// Recognizes a pattern.
<a href=#14 id=14 data-nosnippet>14</a>///
<a href=#15 id=15 data-nosnippet>15</a>/// The input data will be compared to the tag combinator's argument and will return the part of
<a href=#16 id=16 data-nosnippet>16</a>/// the input that matches the argument.
<a href=#17 id=17 data-nosnippet>17</a>/// # Example
<a href=#18 id=18 data-nosnippet>18</a>/// ```rust
<a href=#19 id=19 data-nosnippet>19</a>/// # use nom::{Err, error::{Error, ErrorKind}, Needed, IResult};
<a href=#20 id=20 data-nosnippet>20</a>/// use nom::bytes::streaming::tag;
<a href=#21 id=21 data-nosnippet>21</a>///
<a href=#22 id=22 data-nosnippet>22</a>/// fn parser(s: &amp;str) -&gt; IResult&lt;&amp;str, &amp;str&gt; {
<a href=#23 id=23 data-nosnippet>23</a>/// tag("Hello")(s)
<a href=#24 id=24 data-nosnippet>24</a>/// }
<a href=#25 id=25 data-nosnippet>25</a>///
<a href=#26 id=26 data-nosnippet>26</a>/// assert_eq!(parser("Hello, World!"), Ok((", World!", "Hello")));
<a href=#27 id=27 data-nosnippet>27</a>/// assert_eq!(parser("Something"), Err(Err::Error(Error::new("Something", ErrorKind::Tag))));
<a href=#28 id=28 data-nosnippet>28</a>/// assert_eq!(parser("S"), Err(Err::Error(Error::new("S", ErrorKind::Tag))));
<a href=#29 id=29 data-nosnippet>29</a>/// assert_eq!(parser("H"), Err(Err::Incomplete(Needed::new(4))));
<a href=#30 id=30 data-nosnippet>30</a>/// ```
<a href=#31 id=31 data-nosnippet>31</a></span><span class="kw">pub fn </span>tag&lt;T, I, Error: ParseError&lt;I&gt;&gt;(tag: T) -&gt; <span class="kw">impl </span>Fn(I) -&gt; IResult&lt;I, I, Error&gt;
<a href=#32 id=32 data-nosnippet>32</a><span class="kw">where
<a href=#33 id=33 data-nosnippet>33</a> </span>I: Input + Compare&lt;T&gt;,
<a href=#34 id=34 data-nosnippet>34</a> T: Input + Clone,
<a href=#35 id=35 data-nosnippet>35</a>{
<a href=#36 id=36 data-nosnippet>36</a> <span class="kw">move </span>|i: I| {
<a href=#37 id=37 data-nosnippet>37</a> <span class="kw">let </span><span class="kw-2">mut </span>parser = <span class="kw">super</span>::Tag {
<a href=#38 id=38 data-nosnippet>38</a> tag: tag.clone(),
<a href=#39 id=39 data-nosnippet>39</a> e: PhantomData,
<a href=#40 id=40 data-nosnippet>40</a> };
<a href=#41 id=41 data-nosnippet>41</a>
<a href=#42 id=42 data-nosnippet>42</a> parser.process::&lt;OutputM&lt;Emit, Emit, Streaming&gt;&gt;(i)
<a href=#43 id=43 data-nosnippet>43</a> }
<a href=#44 id=44 data-nosnippet>44</a>}
<a href=#45 id=45 data-nosnippet>45</a>
<a href=#46 id=46 data-nosnippet>46</a><span class="doccomment">/// Recognizes a case insensitive pattern.
<a href=#47 id=47 data-nosnippet>47</a>///
<a href=#48 id=48 data-nosnippet>48</a>/// The input data will be compared to the tag combinator's argument and will return the part of
<a href=#49 id=49 data-nosnippet>49</a>/// the input that matches the argument with no regard to case.
<a href=#50 id=50 data-nosnippet>50</a>/// # Example
<a href=#51 id=51 data-nosnippet>51</a>/// ```rust
<a href=#52 id=52 data-nosnippet>52</a>/// # use nom::{Err, error::{Error, ErrorKind}, Needed, IResult};
<a href=#53 id=53 data-nosnippet>53</a>/// use nom::bytes::streaming::tag_no_case;
<a href=#54 id=54 data-nosnippet>54</a>///
<a href=#55 id=55 data-nosnippet>55</a>/// fn parser(s: &amp;str) -&gt; IResult&lt;&amp;str, &amp;str&gt; {
<a href=#56 id=56 data-nosnippet>56</a>/// tag_no_case("hello")(s)
<a href=#57 id=57 data-nosnippet>57</a>/// }
<a href=#58 id=58 data-nosnippet>58</a>///
<a href=#59 id=59 data-nosnippet>59</a>/// assert_eq!(parser("Hello, World!"), Ok((", World!", "Hello")));
<a href=#60 id=60 data-nosnippet>60</a>/// assert_eq!(parser("hello, World!"), Ok((", World!", "hello")));
<a href=#61 id=61 data-nosnippet>61</a>/// assert_eq!(parser("HeLlO, World!"), Ok((", World!", "HeLlO")));
<a href=#62 id=62 data-nosnippet>62</a>/// assert_eq!(parser("Something"), Err(Err::Error(Error::new("Something", ErrorKind::Tag))));
<a href=#63 id=63 data-nosnippet>63</a>/// assert_eq!(parser(""), Err(Err::Incomplete(Needed::new(5))));
<a href=#64 id=64 data-nosnippet>64</a>/// ```
<a href=#65 id=65 data-nosnippet>65</a></span><span class="kw">pub fn </span>tag_no_case&lt;T, I, Error: ParseError&lt;I&gt;&gt;(tag: T) -&gt; <span class="kw">impl </span>Fn(I) -&gt; IResult&lt;I, I, Error&gt;
<a href=#66 id=66 data-nosnippet>66</a><span class="kw">where
<a href=#67 id=67 data-nosnippet>67</a> </span>I: Input + Compare&lt;T&gt;,
<a href=#68 id=68 data-nosnippet>68</a> T: Input + Clone,
<a href=#69 id=69 data-nosnippet>69</a>{
<a href=#70 id=70 data-nosnippet>70</a> <span class="kw">move </span>|i: I| {
<a href=#71 id=71 data-nosnippet>71</a> <span class="kw">let </span><span class="kw-2">mut </span>parser = <span class="kw">super</span>::TagNoCase {
<a href=#72 id=72 data-nosnippet>72</a> tag: tag.clone(),
<a href=#73 id=73 data-nosnippet>73</a> e: PhantomData,
<a href=#74 id=74 data-nosnippet>74</a> };
<a href=#75 id=75 data-nosnippet>75</a>
<a href=#76 id=76 data-nosnippet>76</a> parser.process::&lt;OutputM&lt;Emit, Emit, Streaming&gt;&gt;(i)
<a href=#77 id=77 data-nosnippet>77</a> }
<a href=#78 id=78 data-nosnippet>78</a>}
<a href=#79 id=79 data-nosnippet>79</a>
<a href=#80 id=80 data-nosnippet>80</a><span class="doccomment">/// Parse till certain characters are met.
<a href=#81 id=81 data-nosnippet>81</a>///
<a href=#82 id=82 data-nosnippet>82</a>/// The parser will return the longest slice till one of the characters of the combinator's argument are met.
<a href=#83 id=83 data-nosnippet>83</a>///
<a href=#84 id=84 data-nosnippet>84</a>/// It doesn't consume the matched character.
<a href=#85 id=85 data-nosnippet>85</a>///
<a href=#86 id=86 data-nosnippet>86</a>/// It will return a `Err::Incomplete(Needed::new(1))` if the pattern wasn't met.
<a href=#87 id=87 data-nosnippet>87</a>/// # Example
<a href=#88 id=88 data-nosnippet>88</a>/// ```rust
<a href=#89 id=89 data-nosnippet>89</a>/// # use nom::{Err, error::ErrorKind, Needed, IResult};
<a href=#90 id=90 data-nosnippet>90</a>/// use nom::bytes::streaming::is_not;
<a href=#91 id=91 data-nosnippet>91</a>///
<a href=#92 id=92 data-nosnippet>92</a>/// fn not_space(s: &amp;str) -&gt; IResult&lt;&amp;str, &amp;str&gt; {
<a href=#93 id=93 data-nosnippet>93</a>/// is_not(" \t\r\n")(s)
<a href=#94 id=94 data-nosnippet>94</a>/// }
<a href=#95 id=95 data-nosnippet>95</a>///
<a href=#96 id=96 data-nosnippet>96</a>/// assert_eq!(not_space("Hello, World!"), Ok((" World!", "Hello,")));
<a href=#97 id=97 data-nosnippet>97</a>/// assert_eq!(not_space("Sometimes\t"), Ok(("\t", "Sometimes")));
<a href=#98 id=98 data-nosnippet>98</a>/// assert_eq!(not_space("Nospace"), Err(Err::Incomplete(Needed::new(1))));
<a href=#99 id=99 data-nosnippet>99</a>/// assert_eq!(not_space(""), Err(Err::Incomplete(Needed::new(1))));
<a href=#100 id=100 data-nosnippet>100</a>/// ```
<a href=#101 id=101 data-nosnippet>101</a></span><span class="kw">pub fn </span>is_not&lt;T, I, Error: ParseError&lt;I&gt;&gt;(arr: T) -&gt; <span class="kw">impl </span>FnMut(I) -&gt; IResult&lt;I, I, Error&gt;
<a href=#102 id=102 data-nosnippet>102</a><span class="kw">where
<a href=#103 id=103 data-nosnippet>103</a> </span>I: Input,
<a href=#104 id=104 data-nosnippet>104</a> T: FindToken&lt;&lt;I <span class="kw">as </span>Input&gt;::Item&gt;,
<a href=#105 id=105 data-nosnippet>105</a>{
<a href=#106 id=106 data-nosnippet>106</a> <span class="kw">let </span><span class="kw-2">mut </span>parser = <span class="kw">super</span>::is_not(arr);
<a href=#107 id=107 data-nosnippet>107</a>
<a href=#108 id=108 data-nosnippet>108</a> <span class="kw">move </span>|i: I| parser.process::&lt;OutputM&lt;Emit, Emit, Streaming&gt;&gt;(i)
<a href=#109 id=109 data-nosnippet>109</a>}
<a href=#110 id=110 data-nosnippet>110</a>
<a href=#111 id=111 data-nosnippet>111</a><span class="doccomment">/// Returns the longest slice of the matches the pattern.
<a href=#112 id=112 data-nosnippet>112</a>///
<a href=#113 id=113 data-nosnippet>113</a>/// The parser will return the longest slice consisting of the characters in provided in the
<a href=#114 id=114 data-nosnippet>114</a>/// combinator's argument.
<a href=#115 id=115 data-nosnippet>115</a>///
<a href=#116 id=116 data-nosnippet>116</a>/// # Streaming specific
<a href=#117 id=117 data-nosnippet>117</a>/// *Streaming version* will return a `Err::Incomplete(Needed::new(1))` if the pattern wasn't met
<a href=#118 id=118 data-nosnippet>118</a>/// or if the pattern reaches the end of the input.
<a href=#119 id=119 data-nosnippet>119</a>/// # Example
<a href=#120 id=120 data-nosnippet>120</a>/// ```rust
<a href=#121 id=121 data-nosnippet>121</a>/// # use nom::{Err, error::ErrorKind, Needed, IResult};
<a href=#122 id=122 data-nosnippet>122</a>/// use nom::bytes::streaming::is_a;
<a href=#123 id=123 data-nosnippet>123</a>///
<a href=#124 id=124 data-nosnippet>124</a>/// fn hex(s: &amp;str) -&gt; IResult&lt;&amp;str, &amp;str&gt; {
<a href=#125 id=125 data-nosnippet>125</a>/// is_a("1234567890ABCDEF")(s)
<a href=#126 id=126 data-nosnippet>126</a>/// }
<a href=#127 id=127 data-nosnippet>127</a>///
<a href=#128 id=128 data-nosnippet>128</a>/// assert_eq!(hex("123 and voila"), Ok((" and voila", "123")));
<a href=#129 id=129 data-nosnippet>129</a>/// assert_eq!(hex("DEADBEEF and others"), Ok((" and others", "DEADBEEF")));
<a href=#130 id=130 data-nosnippet>130</a>/// assert_eq!(hex("BADBABEsomething"), Ok(("something", "BADBABE")));
<a href=#131 id=131 data-nosnippet>131</a>/// assert_eq!(hex("D15EA5E"), Err(Err::Incomplete(Needed::new(1))));
<a href=#132 id=132 data-nosnippet>132</a>/// assert_eq!(hex(""), Err(Err::Incomplete(Needed::new(1))));
<a href=#133 id=133 data-nosnippet>133</a>/// ```
<a href=#134 id=134 data-nosnippet>134</a></span><span class="kw">pub fn </span>is_a&lt;T, I, Error: ParseError&lt;I&gt;&gt;(arr: T) -&gt; <span class="kw">impl </span>FnMut(I) -&gt; IResult&lt;I, I, Error&gt;
<a href=#135 id=135 data-nosnippet>135</a><span class="kw">where
<a href=#136 id=136 data-nosnippet>136</a> </span>I: Input,
<a href=#137 id=137 data-nosnippet>137</a> T: FindToken&lt;&lt;I <span class="kw">as </span>Input&gt;::Item&gt;,
<a href=#138 id=138 data-nosnippet>138</a>{
<a href=#139 id=139 data-nosnippet>139</a> <span class="kw">let </span><span class="kw-2">mut </span>parser = <span class="kw">super</span>::is_a(arr);
<a href=#140 id=140 data-nosnippet>140</a>
<a href=#141 id=141 data-nosnippet>141</a> <span class="kw">move </span>|i: I| parser.process::&lt;OutputM&lt;Emit, Emit, Streaming&gt;&gt;(i)
<a href=#142 id=142 data-nosnippet>142</a>}
<a href=#143 id=143 data-nosnippet>143</a>
<a href=#144 id=144 data-nosnippet>144</a><span class="doccomment">/// Returns the longest input slice (if any) that matches the predicate.
<a href=#145 id=145 data-nosnippet>145</a>///
<a href=#146 id=146 data-nosnippet>146</a>/// The parser will return the longest slice that matches the given predicate *(a function that
<a href=#147 id=147 data-nosnippet>147</a>/// takes the input and returns a bool)*.
<a href=#148 id=148 data-nosnippet>148</a>///
<a href=#149 id=149 data-nosnippet>149</a>/// # Streaming Specific
<a href=#150 id=150 data-nosnippet>150</a>/// *Streaming version* will return a `Err::Incomplete(Needed::new(1))` if the pattern reaches the end of the input.
<a href=#151 id=151 data-nosnippet>151</a>/// # Example
<a href=#152 id=152 data-nosnippet>152</a>/// ```rust
<a href=#153 id=153 data-nosnippet>153</a>/// # use nom::{Err, error::ErrorKind, Needed, IResult};
<a href=#154 id=154 data-nosnippet>154</a>/// use nom::bytes::streaming::take_while;
<a href=#155 id=155 data-nosnippet>155</a>/// use nom::AsChar;
<a href=#156 id=156 data-nosnippet>156</a>///
<a href=#157 id=157 data-nosnippet>157</a>/// fn alpha(s: &amp;[u8]) -&gt; IResult&lt;&amp;[u8], &amp;[u8]&gt; {
<a href=#158 id=158 data-nosnippet>158</a>/// take_while(AsChar::is_alpha)(s)
<a href=#159 id=159 data-nosnippet>159</a>/// }
<a href=#160 id=160 data-nosnippet>160</a>///
<a href=#161 id=161 data-nosnippet>161</a>/// assert_eq!(alpha(b"latin123"), Ok((&amp;b"123"[..], &amp;b"latin"[..])));
<a href=#162 id=162 data-nosnippet>162</a>/// assert_eq!(alpha(b"12345"), Ok((&amp;b"12345"[..], &amp;b""[..])));
<a href=#163 id=163 data-nosnippet>163</a>/// assert_eq!(alpha(b"latin"), Err(Err::Incomplete(Needed::new(1))));
<a href=#164 id=164 data-nosnippet>164</a>/// assert_eq!(alpha(b""), Err(Err::Incomplete(Needed::new(1))));
<a href=#165 id=165 data-nosnippet>165</a>/// ```
<a href=#166 id=166 data-nosnippet>166</a></span><span class="kw">pub fn </span>take_while&lt;F, I, Error: ParseError&lt;I&gt;&gt;(cond: F) -&gt; <span class="kw">impl </span>FnMut(I) -&gt; IResult&lt;I, I, Error&gt;
<a href=#167 id=167 data-nosnippet>167</a><span class="kw">where
<a href=#168 id=168 data-nosnippet>168</a> </span>I: Input,
<a href=#169 id=169 data-nosnippet>169</a> F: Fn(&lt;I <span class="kw">as </span>Input&gt;::Item) -&gt; bool,
<a href=#170 id=170 data-nosnippet>170</a>{
<a href=#171 id=171 data-nosnippet>171</a> <span class="kw">let </span><span class="kw-2">mut </span>parser = <span class="kw">super</span>::take_while(cond);
<a href=#172 id=172 data-nosnippet>172</a>
<a href=#173 id=173 data-nosnippet>173</a> <span class="kw">move </span>|i: I| parser.process::&lt;OutputM&lt;Emit, Emit, Streaming&gt;&gt;(i)
<a href=#174 id=174 data-nosnippet>174</a>}
<a href=#175 id=175 data-nosnippet>175</a>
<a href=#176 id=176 data-nosnippet>176</a><span class="doccomment">/// Returns the longest (at least 1) input slice that matches the predicate.
<a href=#177 id=177 data-nosnippet>177</a>///
<a href=#178 id=178 data-nosnippet>178</a>/// The parser will return the longest slice that matches the given predicate *(a function that
<a href=#179 id=179 data-nosnippet>179</a>/// takes the input and returns a bool)*.
<a href=#180 id=180 data-nosnippet>180</a>///
<a href=#181 id=181 data-nosnippet>181</a>/// It will return an `Err(Err::Error((_, ErrorKind::TakeWhile1)))` if the pattern wasn't met.
<a href=#182 id=182 data-nosnippet>182</a>///
<a href=#183 id=183 data-nosnippet>183</a>/// # Streaming Specific
<a href=#184 id=184 data-nosnippet>184</a>/// *Streaming version* will return a `Err::Incomplete(Needed::new(1))` or if the pattern reaches the end of the input.
<a href=#185 id=185 data-nosnippet>185</a>///
<a href=#186 id=186 data-nosnippet>186</a>/// # Example
<a href=#187 id=187 data-nosnippet>187</a>/// ```rust
<a href=#188 id=188 data-nosnippet>188</a>/// # use nom::{Err, error::{Error, ErrorKind}, Needed, IResult};
<a href=#189 id=189 data-nosnippet>189</a>/// use nom::bytes::streaming::take_while1;
<a href=#190 id=190 data-nosnippet>190</a>/// use nom::AsChar;
<a href=#191 id=191 data-nosnippet>191</a>///
<a href=#192 id=192 data-nosnippet>192</a>/// fn alpha(s: &amp;[u8]) -&gt; IResult&lt;&amp;[u8], &amp;[u8]&gt; {
<a href=#193 id=193 data-nosnippet>193</a>/// take_while1(AsChar::is_alpha)(s)
<a href=#194 id=194 data-nosnippet>194</a>/// }
<a href=#195 id=195 data-nosnippet>195</a>///
<a href=#196 id=196 data-nosnippet>196</a>/// assert_eq!(alpha(b"latin123"), Ok((&amp;b"123"[..], &amp;b"latin"[..])));
<a href=#197 id=197 data-nosnippet>197</a>/// assert_eq!(alpha(b"latin"), Err(Err::Incomplete(Needed::new(1))));
<a href=#198 id=198 data-nosnippet>198</a>/// assert_eq!(alpha(b"12345"), Err(Err::Error(Error::new(&amp;b"12345"[..], ErrorKind::TakeWhile1))));
<a href=#199 id=199 data-nosnippet>199</a>/// ```
<a href=#200 id=200 data-nosnippet>200</a></span><span class="kw">pub fn </span>take_while1&lt;F, I, Error: ParseError&lt;I&gt;&gt;(cond: F) -&gt; <span class="kw">impl </span>FnMut(I) -&gt; IResult&lt;I, I, Error&gt;
<a href=#201 id=201 data-nosnippet>201</a><span class="kw">where
<a href=#202 id=202 data-nosnippet>202</a> </span>I: Input,
<a href=#203 id=203 data-nosnippet>203</a> F: Fn(&lt;I <span class="kw">as </span>Input&gt;::Item) -&gt; bool,
<a href=#204 id=204 data-nosnippet>204</a>{
<a href=#205 id=205 data-nosnippet>205</a> <span class="kw">let </span><span class="kw-2">mut </span>parser = <span class="kw">super</span>::take_while1(cond);
<a href=#206 id=206 data-nosnippet>206</a>
<a href=#207 id=207 data-nosnippet>207</a> <span class="kw">move </span>|i: I| parser.process::&lt;OutputM&lt;Emit, Emit, Streaming&gt;&gt;(i)
<a href=#208 id=208 data-nosnippet>208</a>}
<a href=#209 id=209 data-nosnippet>209</a>
<a href=#210 id=210 data-nosnippet>210</a><span class="doccomment">/// Returns the longest (m &lt;= len &lt;= n) input slice that matches the predicate.
<a href=#211 id=211 data-nosnippet>211</a>///
<a href=#212 id=212 data-nosnippet>212</a>/// The parser will return the longest slice that matches the given predicate *(a function that
<a href=#213 id=213 data-nosnippet>213</a>/// takes the input and returns a bool)*.
<a href=#214 id=214 data-nosnippet>214</a>///
<a href=#215 id=215 data-nosnippet>215</a>/// It will return an `Err::Error((_, ErrorKind::TakeWhileMN))` if the pattern wasn't met.
<a href=#216 id=216 data-nosnippet>216</a>/// # Streaming Specific
<a href=#217 id=217 data-nosnippet>217</a>/// *Streaming version* will return a `Err::Incomplete(Needed::new(1))` if the pattern reaches the end of the input or is too short.
<a href=#218 id=218 data-nosnippet>218</a>///
<a href=#219 id=219 data-nosnippet>219</a>/// # Example
<a href=#220 id=220 data-nosnippet>220</a>/// ```rust
<a href=#221 id=221 data-nosnippet>221</a>/// # use nom::{Err, error::{Error, ErrorKind}, Needed, IResult};
<a href=#222 id=222 data-nosnippet>222</a>/// use nom::bytes::streaming::take_while_m_n;
<a href=#223 id=223 data-nosnippet>223</a>/// use nom::AsChar;
<a href=#224 id=224 data-nosnippet>224</a>///
<a href=#225 id=225 data-nosnippet>225</a>/// fn short_alpha(s: &amp;[u8]) -&gt; IResult&lt;&amp;[u8], &amp;[u8]&gt; {
<a href=#226 id=226 data-nosnippet>226</a>/// take_while_m_n(3, 6, AsChar::is_alpha)(s)
<a href=#227 id=227 data-nosnippet>227</a>/// }
<a href=#228 id=228 data-nosnippet>228</a>///
<a href=#229 id=229 data-nosnippet>229</a>/// assert_eq!(short_alpha(b"latin123"), Ok((&amp;b"123"[..], &amp;b"latin"[..])));
<a href=#230 id=230 data-nosnippet>230</a>/// assert_eq!(short_alpha(b"lengthy"), Ok((&amp;b"y"[..], &amp;b"length"[..])));
<a href=#231 id=231 data-nosnippet>231</a>/// assert_eq!(short_alpha(b"latin"), Err(Err::Incomplete(Needed::new(1))));
<a href=#232 id=232 data-nosnippet>232</a>/// assert_eq!(short_alpha(b"ed"), Err(Err::Incomplete(Needed::new(1))));
<a href=#233 id=233 data-nosnippet>233</a>/// assert_eq!(short_alpha(b"12345"), Err(Err::Error(Error::new(&amp;b"12345"[..], ErrorKind::TakeWhileMN))));
<a href=#234 id=234 data-nosnippet>234</a>/// ```
<a href=#235 id=235 data-nosnippet>235</a></span><span class="kw">pub fn </span>take_while_m_n&lt;F, I, Error: ParseError&lt;I&gt;&gt;(
<a href=#236 id=236 data-nosnippet>236</a> m: usize,
<a href=#237 id=237 data-nosnippet>237</a> n: usize,
<a href=#238 id=238 data-nosnippet>238</a> cond: F,
<a href=#239 id=239 data-nosnippet>239</a>) -&gt; <span class="kw">impl </span>FnMut(I) -&gt; IResult&lt;I, I, Error&gt;
<a href=#240 id=240 data-nosnippet>240</a><span class="kw">where
<a href=#241 id=241 data-nosnippet>241</a> </span>I: Input,
<a href=#242 id=242 data-nosnippet>242</a> F: Fn(&lt;I <span class="kw">as </span>Input&gt;::Item) -&gt; bool,
<a href=#243 id=243 data-nosnippet>243</a>{
<a href=#244 id=244 data-nosnippet>244</a> <span class="kw">let </span><span class="kw-2">mut </span>parser = <span class="kw">super</span>::take_while_m_n(m, n, cond);
<a href=#245 id=245 data-nosnippet>245</a>
<a href=#246 id=246 data-nosnippet>246</a> <span class="kw">move </span>|i: I| parser.process::&lt;OutputM&lt;Emit, Emit, Streaming&gt;&gt;(i)
<a href=#247 id=247 data-nosnippet>247</a>}
<a href=#248 id=248 data-nosnippet>248</a>
<a href=#249 id=249 data-nosnippet>249</a><span class="doccomment">/// Returns the longest input slice (if any) till a predicate is met.
<a href=#250 id=250 data-nosnippet>250</a>///
<a href=#251 id=251 data-nosnippet>251</a>/// The parser will return the longest slice till the given predicate *(a function that
<a href=#252 id=252 data-nosnippet>252</a>/// takes the input and returns a bool)*.
<a href=#253 id=253 data-nosnippet>253</a>///
<a href=#254 id=254 data-nosnippet>254</a>/// # Streaming Specific
<a href=#255 id=255 data-nosnippet>255</a>/// *Streaming version* will return a `Err::Incomplete(Needed::new(1))` if the match reaches the
<a href=#256 id=256 data-nosnippet>256</a>/// end of input or if there was not match.
<a href=#257 id=257 data-nosnippet>257</a>///
<a href=#258 id=258 data-nosnippet>258</a>/// # Example
<a href=#259 id=259 data-nosnippet>259</a>/// ```rust
<a href=#260 id=260 data-nosnippet>260</a>/// # use nom::{Err, error::ErrorKind, Needed, IResult};
<a href=#261 id=261 data-nosnippet>261</a>/// use nom::bytes::streaming::take_till;
<a href=#262 id=262 data-nosnippet>262</a>///
<a href=#263 id=263 data-nosnippet>263</a>/// fn till_colon(s: &amp;str) -&gt; IResult&lt;&amp;str, &amp;str&gt; {
<a href=#264 id=264 data-nosnippet>264</a>/// take_till(|c| c == ':')(s)
<a href=#265 id=265 data-nosnippet>265</a>/// }
<a href=#266 id=266 data-nosnippet>266</a>///
<a href=#267 id=267 data-nosnippet>267</a>/// assert_eq!(till_colon("latin:123"), Ok((":123", "latin")));
<a href=#268 id=268 data-nosnippet>268</a>/// assert_eq!(till_colon(":empty matched"), Ok((":empty matched", ""))); //allowed
<a href=#269 id=269 data-nosnippet>269</a>/// assert_eq!(till_colon("12345"), Err(Err::Incomplete(Needed::new(1))));
<a href=#270 id=270 data-nosnippet>270</a>/// assert_eq!(till_colon(""), Err(Err::Incomplete(Needed::new(1))));
<a href=#271 id=271 data-nosnippet>271</a>/// ```
<a href=#272 id=272 data-nosnippet>272</a></span><span class="attr">#[allow(clippy::redundant_closure)]
<a href=#273 id=273 data-nosnippet>273</a></span><span class="kw">pub fn </span>take_till&lt;F, I, Error: ParseError&lt;I&gt;&gt;(cond: F) -&gt; <span class="kw">impl </span>FnMut(I) -&gt; IResult&lt;I, I, Error&gt;
<a href=#274 id=274 data-nosnippet>274</a><span class="kw">where
<a href=#275 id=275 data-nosnippet>275</a> </span>I: Input,
<a href=#276 id=276 data-nosnippet>276</a> F: Fn(&lt;I <span class="kw">as </span>Input&gt;::Item) -&gt; bool,
<a href=#277 id=277 data-nosnippet>277</a>{
<a href=#278 id=278 data-nosnippet>278</a> <span class="kw">let </span><span class="kw-2">mut </span>parser = <span class="kw">super</span>::take_till(cond);
<a href=#279 id=279 data-nosnippet>279</a>
<a href=#280 id=280 data-nosnippet>280</a> <span class="kw">move </span>|i: I| parser.process::&lt;OutputM&lt;Emit, Emit, Streaming&gt;&gt;(i)
<a href=#281 id=281 data-nosnippet>281</a>}
<a href=#282 id=282 data-nosnippet>282</a>
<a href=#283 id=283 data-nosnippet>283</a><span class="doccomment">/// Returns the longest (at least 1) input slice till a predicate is met.
<a href=#284 id=284 data-nosnippet>284</a>///
<a href=#285 id=285 data-nosnippet>285</a>/// The parser will return the longest slice till the given predicate *(a function that
<a href=#286 id=286 data-nosnippet>286</a>/// takes the input and returns a bool)*.
<a href=#287 id=287 data-nosnippet>287</a>///
<a href=#288 id=288 data-nosnippet>288</a>/// # Streaming Specific
<a href=#289 id=289 data-nosnippet>289</a>/// *Streaming version* will return a `Err::Incomplete(Needed::new(1))` if the match reaches the
<a href=#290 id=290 data-nosnippet>290</a>/// end of input or if there was not match.
<a href=#291 id=291 data-nosnippet>291</a>/// # Example
<a href=#292 id=292 data-nosnippet>292</a>/// ```rust
<a href=#293 id=293 data-nosnippet>293</a>/// # use nom::{Err, error::{Error, ErrorKind}, Needed, IResult};
<a href=#294 id=294 data-nosnippet>294</a>/// use nom::bytes::streaming::take_till1;
<a href=#295 id=295 data-nosnippet>295</a>///
<a href=#296 id=296 data-nosnippet>296</a>/// fn till_colon(s: &amp;str) -&gt; IResult&lt;&amp;str, &amp;str&gt; {
<a href=#297 id=297 data-nosnippet>297</a>/// take_till1(|c| c == ':')(s)
<a href=#298 id=298 data-nosnippet>298</a>/// }
<a href=#299 id=299 data-nosnippet>299</a>///
<a href=#300 id=300 data-nosnippet>300</a>/// assert_eq!(till_colon("latin:123"), Ok((":123", "latin")));
<a href=#301 id=301 data-nosnippet>301</a>/// assert_eq!(till_colon(":empty matched"), Err(Err::Error(Error::new(":empty matched", ErrorKind::TakeTill1))));
<a href=#302 id=302 data-nosnippet>302</a>/// assert_eq!(till_colon("12345"), Err(Err::Incomplete(Needed::new(1))));
<a href=#303 id=303 data-nosnippet>303</a>/// assert_eq!(till_colon(""), Err(Err::Incomplete(Needed::new(1))));
<a href=#304 id=304 data-nosnippet>304</a>/// ```
<a href=#305 id=305 data-nosnippet>305</a></span><span class="attr">#[allow(clippy::redundant_closure)]
<a href=#306 id=306 data-nosnippet>306</a></span><span class="kw">pub fn </span>take_till1&lt;F, I, Error: ParseError&lt;I&gt;&gt;(cond: F) -&gt; <span class="kw">impl </span>FnMut(I) -&gt; IResult&lt;I, I, Error&gt;
<a href=#307 id=307 data-nosnippet>307</a><span class="kw">where
<a href=#308 id=308 data-nosnippet>308</a> </span>I: Input,
<a href=#309 id=309 data-nosnippet>309</a> F: Fn(&lt;I <span class="kw">as </span>Input&gt;::Item) -&gt; bool,
<a href=#310 id=310 data-nosnippet>310</a>{
<a href=#311 id=311 data-nosnippet>311</a> <span class="kw">let </span><span class="kw-2">mut </span>parser = <span class="kw">super</span>::take_till1(cond);
<a href=#312 id=312 data-nosnippet>312</a>
<a href=#313 id=313 data-nosnippet>313</a> <span class="kw">move </span>|i: I| parser.process::&lt;OutputM&lt;Emit, Emit, Streaming&gt;&gt;(i)
<a href=#314 id=314 data-nosnippet>314</a>}
<a href=#315 id=315 data-nosnippet>315</a>
<a href=#316 id=316 data-nosnippet>316</a><span class="doccomment">/// Returns an input slice containing the first N input elements (Input[..N]).
<a href=#317 id=317 data-nosnippet>317</a>///
<a href=#318 id=318 data-nosnippet>318</a>/// # Streaming Specific
<a href=#319 id=319 data-nosnippet>319</a>/// *Streaming version* if the input has less than N elements, `take` will
<a href=#320 id=320 data-nosnippet>320</a>/// return a `Err::Incomplete(Needed::new(M))` where M is the number of
<a href=#321 id=321 data-nosnippet>321</a>/// additional bytes the parser would need to succeed.
<a href=#322 id=322 data-nosnippet>322</a>/// It is well defined for `&amp;[u8]` as the number of elements is the byte size,
<a href=#323 id=323 data-nosnippet>323</a>/// but for types like `&amp;str`, we cannot know how many bytes correspond for
<a href=#324 id=324 data-nosnippet>324</a>/// the next few chars, so the result will be `Err::Incomplete(Needed::Unknown)`
<a href=#325 id=325 data-nosnippet>325</a>///
<a href=#326 id=326 data-nosnippet>326</a>/// # Example
<a href=#327 id=327 data-nosnippet>327</a>/// ```rust
<a href=#328 id=328 data-nosnippet>328</a>/// # use nom::{Err, error::ErrorKind, Needed, IResult};
<a href=#329 id=329 data-nosnippet>329</a>/// use nom::bytes::streaming::take;
<a href=#330 id=330 data-nosnippet>330</a>///
<a href=#331 id=331 data-nosnippet>331</a>/// fn take6(s: &amp;str) -&gt; IResult&lt;&amp;str, &amp;str&gt; {
<a href=#332 id=332 data-nosnippet>332</a>/// take(6usize)(s)
<a href=#333 id=333 data-nosnippet>333</a>/// }
<a href=#334 id=334 data-nosnippet>334</a>///
<a href=#335 id=335 data-nosnippet>335</a>/// assert_eq!(take6("1234567"), Ok(("7", "123456")));
<a href=#336 id=336 data-nosnippet>336</a>/// assert_eq!(take6("things"), Ok(("", "things")));
<a href=#337 id=337 data-nosnippet>337</a>/// assert_eq!(take6("short"), Err(Err::Incomplete(Needed::Unknown)));
<a href=#338 id=338 data-nosnippet>338</a>/// ```
<a href=#339 id=339 data-nosnippet>339</a></span><span class="kw">pub fn </span>take&lt;C, I, Error: ParseError&lt;I&gt;&gt;(count: C) -&gt; <span class="kw">impl </span>FnMut(I) -&gt; IResult&lt;I, I, Error&gt;
<a href=#340 id=340 data-nosnippet>340</a><span class="kw">where
<a href=#341 id=341 data-nosnippet>341</a> </span>I: Input,
<a href=#342 id=342 data-nosnippet>342</a> C: ToUsize,
<a href=#343 id=343 data-nosnippet>343</a>{
<a href=#344 id=344 data-nosnippet>344</a> <span class="kw">let </span><span class="kw-2">mut </span>parser = <span class="kw">super</span>::take(count);
<a href=#345 id=345 data-nosnippet>345</a>
<a href=#346 id=346 data-nosnippet>346</a> <span class="kw">move </span>|i: I| parser.process::&lt;OutputM&lt;Emit, Emit, Streaming&gt;&gt;(i)
<a href=#347 id=347 data-nosnippet>347</a>}
<a href=#348 id=348 data-nosnippet>348</a>
<a href=#349 id=349 data-nosnippet>349</a><span class="doccomment">/// Returns the input slice up to the first occurrence of the pattern.
<a href=#350 id=350 data-nosnippet>350</a>///
<a href=#351 id=351 data-nosnippet>351</a>/// It doesn't consume the pattern.
<a href=#352 id=352 data-nosnippet>352</a>///
<a href=#353 id=353 data-nosnippet>353</a>/// # Streaming Specific
<a href=#354 id=354 data-nosnippet>354</a>/// *Streaming version* will return a `Err::Incomplete(Needed::new(N))` if the input doesn't
<a href=#355 id=355 data-nosnippet>355</a>/// contain the pattern or if the input is smaller than the pattern.
<a href=#356 id=356 data-nosnippet>356</a>/// # Example
<a href=#357 id=357 data-nosnippet>357</a>/// ```rust
<a href=#358 id=358 data-nosnippet>358</a>/// # use nom::{Err, error::ErrorKind, Needed, IResult};
<a href=#359 id=359 data-nosnippet>359</a>/// use nom::bytes::streaming::take_until;
<a href=#360 id=360 data-nosnippet>360</a>///
<a href=#361 id=361 data-nosnippet>361</a>/// fn until_eof(s: &amp;str) -&gt; IResult&lt;&amp;str, &amp;str&gt; {
<a href=#362 id=362 data-nosnippet>362</a>/// take_until("eof")(s)
<a href=#363 id=363 data-nosnippet>363</a>/// }
<a href=#364 id=364 data-nosnippet>364</a>///
<a href=#365 id=365 data-nosnippet>365</a>/// assert_eq!(until_eof("hello, worldeof"), Ok(("eof", "hello, world")));
<a href=#366 id=366 data-nosnippet>366</a>/// assert_eq!(until_eof("hello, world"), Err(Err::Incomplete(Needed::Unknown)));
<a href=#367 id=367 data-nosnippet>367</a>/// assert_eq!(until_eof("hello, worldeo"), Err(Err::Incomplete(Needed::Unknown)));
<a href=#368 id=368 data-nosnippet>368</a>/// assert_eq!(until_eof("1eof2eof"), Ok(("eof2eof", "1")));
<a href=#369 id=369 data-nosnippet>369</a>/// ```
<a href=#370 id=370 data-nosnippet>370</a></span><span class="kw">pub fn </span>take_until&lt;T, I, Error: ParseError&lt;I&gt;&gt;(tag: T) -&gt; <span class="kw">impl </span>FnMut(I) -&gt; IResult&lt;I, I, Error&gt;
<a href=#371 id=371 data-nosnippet>371</a><span class="kw">where
<a href=#372 id=372 data-nosnippet>372</a> </span>I: Input + FindSubstring&lt;T&gt;,
<a href=#373 id=373 data-nosnippet>373</a> T: Clone,
<a href=#374 id=374 data-nosnippet>374</a>{
<a href=#375 id=375 data-nosnippet>375</a> <span class="kw">let </span><span class="kw-2">mut </span>parser = <span class="kw">super</span>::take_until(tag);
<a href=#376 id=376 data-nosnippet>376</a>
<a href=#377 id=377 data-nosnippet>377</a> <span class="kw">move </span>|i: I| parser.process::&lt;OutputM&lt;Emit, Emit, Streaming&gt;&gt;(i)
<a href=#378 id=378 data-nosnippet>378</a>}
<a href=#379 id=379 data-nosnippet>379</a>
<a href=#380 id=380 data-nosnippet>380</a><span class="doccomment">/// Returns the non empty input slice up to the first occurrence of the pattern.
<a href=#381 id=381 data-nosnippet>381</a>///
<a href=#382 id=382 data-nosnippet>382</a>/// It doesn't consume the pattern.
<a href=#383 id=383 data-nosnippet>383</a>///
<a href=#384 id=384 data-nosnippet>384</a>/// # Streaming Specific
<a href=#385 id=385 data-nosnippet>385</a>/// *Streaming version* will return a `Err::Incomplete(Needed::new(N))` if the input doesn't
<a href=#386 id=386 data-nosnippet>386</a>/// contain the pattern or if the input is smaller than the pattern.
<a href=#387 id=387 data-nosnippet>387</a>/// # Example
<a href=#388 id=388 data-nosnippet>388</a>/// ```rust
<a href=#389 id=389 data-nosnippet>389</a>/// # use nom::{Err, error::{Error, ErrorKind}, Needed, IResult};
<a href=#390 id=390 data-nosnippet>390</a>/// use nom::bytes::streaming::take_until1;
<a href=#391 id=391 data-nosnippet>391</a>///
<a href=#392 id=392 data-nosnippet>392</a>/// fn until_eof(s: &amp;str) -&gt; IResult&lt;&amp;str, &amp;str&gt; {
<a href=#393 id=393 data-nosnippet>393</a>/// take_until1("eof")(s)
<a href=#394 id=394 data-nosnippet>394</a>/// }
<a href=#395 id=395 data-nosnippet>395</a>///
<a href=#396 id=396 data-nosnippet>396</a>/// assert_eq!(until_eof("hello, worldeof"), Ok(("eof", "hello, world")));
<a href=#397 id=397 data-nosnippet>397</a>/// assert_eq!(until_eof("hello, world"), Err(Err::Incomplete(Needed::Unknown)));
<a href=#398 id=398 data-nosnippet>398</a>/// assert_eq!(until_eof("hello, worldeo"), Err(Err::Incomplete(Needed::Unknown)));
<a href=#399 id=399 data-nosnippet>399</a>/// assert_eq!(until_eof("1eof2eof"), Ok(("eof2eof", "1")));
<a href=#400 id=400 data-nosnippet>400</a>/// assert_eq!(until_eof("eof"), Err(Err::Error(Error::new("eof", ErrorKind::TakeUntil))));
<a href=#401 id=401 data-nosnippet>401</a>/// ```
<a href=#402 id=402 data-nosnippet>402</a></span><span class="kw">pub fn </span>take_until1&lt;T, I, Error: ParseError&lt;I&gt;&gt;(tag: T) -&gt; <span class="kw">impl </span>FnMut(I) -&gt; IResult&lt;I, I, Error&gt;
<a href=#403 id=403 data-nosnippet>403</a><span class="kw">where
<a href=#404 id=404 data-nosnippet>404</a> </span>I: Input + FindSubstring&lt;T&gt;,
<a href=#405 id=405 data-nosnippet>405</a> T: Clone,
<a href=#406 id=406 data-nosnippet>406</a>{
<a href=#407 id=407 data-nosnippet>407</a> <span class="kw">let </span><span class="kw-2">mut </span>parser = <span class="kw">super</span>::take_until1(tag);
<a href=#408 id=408 data-nosnippet>408</a>
<a href=#409 id=409 data-nosnippet>409</a> <span class="kw">move </span>|i: I| parser.process::&lt;OutputM&lt;Emit, Emit, Streaming&gt;&gt;(i)
<a href=#410 id=410 data-nosnippet>410</a>}
<a href=#411 id=411 data-nosnippet>411</a>
<a href=#412 id=412 data-nosnippet>412</a><span class="doccomment">/// Matches a byte string with escaped characters.
<a href=#413 id=413 data-nosnippet>413</a>///
<a href=#414 id=414 data-nosnippet>414</a>/// * The first argument matches the normal characters (it must not accept the control character)
<a href=#415 id=415 data-nosnippet>415</a>/// * The second argument is the control character (like `\` in most languages)
<a href=#416 id=416 data-nosnippet>416</a>/// * The third argument matches the escaped characters
<a href=#417 id=417 data-nosnippet>417</a>/// # Example
<a href=#418 id=418 data-nosnippet>418</a>/// ```
<a href=#419 id=419 data-nosnippet>419</a>/// # use nom::{Err, error::ErrorKind, Needed, IResult};
<a href=#420 id=420 data-nosnippet>420</a>/// # use nom::character::complete::digit1;
<a href=#421 id=421 data-nosnippet>421</a>/// use nom::bytes::streaming::escaped;
<a href=#422 id=422 data-nosnippet>422</a>/// use nom::character::streaming::one_of;
<a href=#423 id=423 data-nosnippet>423</a>///
<a href=#424 id=424 data-nosnippet>424</a>/// fn esc(s: &amp;str) -&gt; IResult&lt;&amp;str, &amp;str&gt; {
<a href=#425 id=425 data-nosnippet>425</a>/// escaped(digit1, '\\', one_of("\"n\\"))(s)
<a href=#426 id=426 data-nosnippet>426</a>/// }
<a href=#427 id=427 data-nosnippet>427</a>///
<a href=#428 id=428 data-nosnippet>428</a>/// assert_eq!(esc("123;"), Ok((";", "123")));
<a href=#429 id=429 data-nosnippet>429</a>/// assert_eq!(esc("12\\\"34;"), Ok((";", "12\\\"34")));
<a href=#430 id=430 data-nosnippet>430</a>/// ```
<a href=#431 id=431 data-nosnippet>431</a>///
<a href=#432 id=432 data-nosnippet>432</a></span><span class="kw">pub fn </span>escaped&lt;I, Error, F, G&gt;(
<a href=#433 id=433 data-nosnippet>433</a> normal: F,
<a href=#434 id=434 data-nosnippet>434</a> control_char: char,
<a href=#435 id=435 data-nosnippet>435</a> escapable: G,
<a href=#436 id=436 data-nosnippet>436</a>) -&gt; <span class="kw">impl </span>FnMut(I) -&gt; IResult&lt;I, I, Error&gt;
<a href=#437 id=437 data-nosnippet>437</a><span class="kw">where
<a href=#438 id=438 data-nosnippet>438</a> </span>I: Input + Clone + <span class="kw">crate</span>::traits::Offset,
<a href=#439 id=439 data-nosnippet>439</a> &lt;I <span class="kw">as </span>Input&gt;::Item: <span class="kw">crate</span>::traits::AsChar,
<a href=#440 id=440 data-nosnippet>440</a> F: Parser&lt;I, Error = Error&gt;,
<a href=#441 id=441 data-nosnippet>441</a> G: Parser&lt;I, Error = Error&gt;,
<a href=#442 id=442 data-nosnippet>442</a> Error: ParseError&lt;I&gt;,
<a href=#443 id=443 data-nosnippet>443</a>{
<a href=#444 id=444 data-nosnippet>444</a> <span class="kw">let </span><span class="kw-2">mut </span>parser = <span class="kw">super</span>::escaped(normal, control_char, escapable);
<a href=#445 id=445 data-nosnippet>445</a>
<a href=#446 id=446 data-nosnippet>446</a> <span class="kw">move </span>|i: I| parser.process::&lt;OutputM&lt;Emit, Emit, Streaming&gt;&gt;(i)
<a href=#447 id=447 data-nosnippet>447</a>}
<a href=#448 id=448 data-nosnippet>448</a>
<a href=#449 id=449 data-nosnippet>449</a><span class="doccomment">/// Matches a byte string with escaped characters.
<a href=#450 id=450 data-nosnippet>450</a>///
<a href=#451 id=451 data-nosnippet>451</a>/// * The first argument matches the normal characters (it must not match the control character)
<a href=#452 id=452 data-nosnippet>452</a>/// * The second argument is the control character (like `\` in most languages)
<a href=#453 id=453 data-nosnippet>453</a>/// * The third argument matches the escaped characters and transforms them
<a href=#454 id=454 data-nosnippet>454</a>///
<a href=#455 id=455 data-nosnippet>455</a>/// As an example, the chain `abc\tdef` could be `abc def` (it also consumes the control character)
<a href=#456 id=456 data-nosnippet>456</a>///
<a href=#457 id=457 data-nosnippet>457</a>/// ```
<a href=#458 id=458 data-nosnippet>458</a>/// # use nom::{Err, error::ErrorKind, Needed, IResult};
<a href=#459 id=459 data-nosnippet>459</a>/// # use std::str::from_utf8;
<a href=#460 id=460 data-nosnippet>460</a>/// use nom::bytes::streaming::{escaped_transform, tag};
<a href=#461 id=461 data-nosnippet>461</a>/// use nom::character::streaming::alpha1;
<a href=#462 id=462 data-nosnippet>462</a>/// use nom::branch::alt;
<a href=#463 id=463 data-nosnippet>463</a>/// use nom::combinator::value;
<a href=#464 id=464 data-nosnippet>464</a>///
<a href=#465 id=465 data-nosnippet>465</a>/// fn parser(input: &amp;str) -&gt; IResult&lt;&amp;str, String&gt; {
<a href=#466 id=466 data-nosnippet>466</a>/// escaped_transform(
<a href=#467 id=467 data-nosnippet>467</a>/// alpha1,
<a href=#468 id=468 data-nosnippet>468</a>/// '\\',
<a href=#469 id=469 data-nosnippet>469</a>/// alt((
<a href=#470 id=470 data-nosnippet>470</a>/// value("\\", tag("\\")),
<a href=#471 id=471 data-nosnippet>471</a>/// value("\"", tag("\"")),
<a href=#472 id=472 data-nosnippet>472</a>/// value("\n", tag("n")),
<a href=#473 id=473 data-nosnippet>473</a>/// ))
<a href=#474 id=474 data-nosnippet>474</a>/// )(input)
<a href=#475 id=475 data-nosnippet>475</a>/// }
<a href=#476 id=476 data-nosnippet>476</a>///
<a href=#477 id=477 data-nosnippet>477</a>/// assert_eq!(parser("ab\\\"cd\""), Ok(("\"", String::from("ab\"cd"))));
<a href=#478 id=478 data-nosnippet>478</a>/// ```
<a href=#479 id=479 data-nosnippet>479</a></span><span class="attr">#[cfg(feature = <span class="string">"alloc"</span>)]
<a href=#480 id=480 data-nosnippet>480</a>#[cfg_attr(feature = <span class="string">"docsrs"</span>, doc(cfg(feature = <span class="string">"alloc"</span>)))]
<a href=#481 id=481 data-nosnippet>481</a></span><span class="kw">pub fn </span>escaped_transform&lt;I, Error, F, G, O1, O2, ExtendItem, Output&gt;(
<a href=#482 id=482 data-nosnippet>482</a> normal: F,
<a href=#483 id=483 data-nosnippet>483</a> control_char: char,
<a href=#484 id=484 data-nosnippet>484</a> transform: G,
<a href=#485 id=485 data-nosnippet>485</a>) -&gt; <span class="kw">impl </span>FnMut(I) -&gt; IResult&lt;I, Output, Error&gt;
<a href=#486 id=486 data-nosnippet>486</a><span class="kw">where
<a href=#487 id=487 data-nosnippet>487</a> </span>I: Clone + <span class="kw">crate</span>::traits::Offset + Input,
<a href=#488 id=488 data-nosnippet>488</a> I: <span class="kw">crate</span>::traits::ExtendInto&lt;Item = ExtendItem, Extender = Output&gt;,
<a href=#489 id=489 data-nosnippet>489</a> O1: <span class="kw">crate</span>::traits::ExtendInto&lt;Item = ExtendItem, Extender = Output&gt;,
<a href=#490 id=490 data-nosnippet>490</a> O2: <span class="kw">crate</span>::traits::ExtendInto&lt;Item = ExtendItem, Extender = Output&gt;,
<a href=#491 id=491 data-nosnippet>491</a> &lt;I <span class="kw">as </span>Input&gt;::Item: <span class="kw">crate</span>::traits::AsChar,
<a href=#492 id=492 data-nosnippet>492</a> F: Parser&lt;I, Output = O1, Error = Error&gt;,
<a href=#493 id=493 data-nosnippet>493</a> G: Parser&lt;I, Output = O2, Error = Error&gt;,
<a href=#494 id=494 data-nosnippet>494</a> Error: ParseError&lt;I&gt;,
<a href=#495 id=495 data-nosnippet>495</a>{
<a href=#496 id=496 data-nosnippet>496</a> <span class="kw">let </span><span class="kw-2">mut </span>parser = <span class="kw">super</span>::escaped_transform(normal, control_char, transform);
<a href=#497 id=497 data-nosnippet>497</a>
<a href=#498 id=498 data-nosnippet>498</a> <span class="kw">move </span>|i: I| parser.process::&lt;OutputM&lt;Emit, Emit, Streaming&gt;&gt;(i)
<a href=#499 id=499 data-nosnippet>499</a>}
</code></pre></div></section></main></body></html>
File diff suppressed because it is too large Load Diff
+403
View File
@@ -0,0 +1,403 @@
<!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 of the Rust file `/home/newkirk/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/nom-8.0.0/src/character/mod.rs`."><title>mod.rs - source</title><script>if(window.location.protocol!=="file:")document.head.insertAdjacentHTML("beforeend","SourceSerif4-Regular-6b053e98.ttf.woff2,FiraSans-Italic-81dc35de.woff2,FiraSans-Regular-0fe48ade.woff2,FiraSans-MediumItalic-ccf7e434.woff2,FiraSans-Medium-e1aa3f0a.woff2,SourceCodePro-Regular-8badfe75.ttf.woff2,SourceCodePro-Semibold-aa29a496.ttf.woff2".split(",").map(f=>`<link rel="preload" as="font" type="font/woff2"href="../../../static.files/${f}">`).join(""))</script><link rel="stylesheet" href="../../../static.files/normalize-9960930a.css"><link rel="stylesheet" href="../../../static.files/rustdoc-ca0dd0c4.css"><meta name="rustdoc-vars" data-root-path="../../../" data-static-root-path="../../../static.files/" data-current-crate="nom" data-themes="" data-resource-suffix="" data-rustdoc-version="1.93.1 (01f6ddf75 2026-02-11) (Arch Linux rust 1:1.93.1-1)" data-channel="1.93.1" data-search-js="search-9e2438ea.js" data-stringdex-js="stringdex-a3946164.js" data-settings-js="settings-c38705f0.js" ><script src="../../../static.files/storage-e2aeef58.js"></script><script defer src="../../../static.files/src-script-813739b1.js"></script><script defer src="../../../src-files.js"></script><script defer src="../../../static.files/main-a410ff4d.js"></script><noscript><link rel="stylesheet" href="../../../static.files/noscript-263c88ec.css"></noscript><link rel="alternate icon" type="image/png" href="../../../static.files/favicon-32x32-eab170b8.png"><link rel="icon" type="image/svg+xml" href="../../../static.files/favicon-044be391.svg"></head><body class="rustdoc src"><!--[if lte IE 11]><div class="warning">This old browser is unsupported and will most likely display funky things.</div><![endif]--><nav class="sidebar"><div class="src-sidebar-title"><h2>Files</h2></div></nav><div class="sidebar-resizer" title="Drag to resize sidebar"></div><main><section id="main-content" class="content"><div class="main-heading"><h1><div class="sub-heading">nom/character/</div>mod.rs</h1><rustdoc-toolbar></rustdoc-toolbar></div><div class="example-wrap digits-3"><pre class="rust"><code><a href=#1 id=1 data-nosnippet>1</a><span class="doccomment">//! Character specific parsers and combinators
<a href=#2 id=2 data-nosnippet>2</a>//!
<a href=#3 id=3 data-nosnippet>3</a>//! Functions recognizing specific characters
<a href=#4 id=4 data-nosnippet>4</a>
<a href=#5 id=5 data-nosnippet>5</a></span><span class="kw">use </span>core::marker::PhantomData;
<a href=#6 id=6 data-nosnippet>6</a>
<a href=#7 id=7 data-nosnippet>7</a><span class="kw">use </span><span class="kw">crate</span>::error::ErrorKind;
<a href=#8 id=8 data-nosnippet>8</a><span class="kw">use </span><span class="kw">crate</span>::FindToken;
<a href=#9 id=9 data-nosnippet>9</a><span class="kw">use </span><span class="kw">crate</span>::IsStreaming;
<a href=#10 id=10 data-nosnippet>10</a><span class="kw">use </span><span class="kw">crate</span>::Mode;
<a href=#11 id=11 data-nosnippet>11</a><span class="kw">use crate</span>::{error::ParseError, AsChar, <span class="prelude-val">Err</span>, IResult, Input, Needed, Parser};
<a href=#12 id=12 data-nosnippet>12</a>
<a href=#13 id=13 data-nosnippet>13</a><span class="attr">#[cfg(test)]
<a href=#14 id=14 data-nosnippet>14</a></span><span class="kw">mod </span>tests;
<a href=#15 id=15 data-nosnippet>15</a>
<a href=#16 id=16 data-nosnippet>16</a><span class="kw">pub mod </span>complete;
<a href=#17 id=17 data-nosnippet>17</a><span class="kw">pub mod </span>streaming;
<a href=#18 id=18 data-nosnippet>18</a>
<a href=#19 id=19 data-nosnippet>19</a><span class="attr">#[inline]
<a href=#20 id=20 data-nosnippet>20</a>#[doc(hidden)]
<a href=#21 id=21 data-nosnippet>21</a>#[deprecated(since = <span class="string">"8.0.0"</span>, note = <span class="string">"Replaced with `AsChar::is_alpha`"</span>)]
<a href=#22 id=22 data-nosnippet>22</a></span><span class="kw">pub fn </span>is_alphabetic(chr: u8) -&gt; bool {
<a href=#23 id=23 data-nosnippet>23</a> <span class="macro">matches!</span>(chr, <span class="number">0x41</span>..=<span class="number">0x5A </span>| <span class="number">0x61</span>..=<span class="number">0x7A</span>)
<a href=#24 id=24 data-nosnippet>24</a>}
<a href=#25 id=25 data-nosnippet>25</a>
<a href=#26 id=26 data-nosnippet>26</a><span class="attr">#[inline]
<a href=#27 id=27 data-nosnippet>27</a>#[doc(hidden)]
<a href=#28 id=28 data-nosnippet>28</a>#[deprecated(since = <span class="string">"8.0.0"</span>, note = <span class="string">"Replaced with `AsChar::is_dec_digit`"</span>)]
<a href=#29 id=29 data-nosnippet>29</a></span><span class="kw">pub fn </span>is_digit(chr: u8) -&gt; bool {
<a href=#30 id=30 data-nosnippet>30</a> <span class="macro">matches!</span>(chr, <span class="number">0x30</span>..=<span class="number">0x39</span>)
<a href=#31 id=31 data-nosnippet>31</a>}
<a href=#32 id=32 data-nosnippet>32</a>
<a href=#33 id=33 data-nosnippet>33</a><span class="attr">#[inline]
<a href=#34 id=34 data-nosnippet>34</a>#[doc(hidden)]
<a href=#35 id=35 data-nosnippet>35</a>#[deprecated(since = <span class="string">"8.0.0"</span>, note = <span class="string">"Replaced with `AsChar::is_hex_digit`"</span>)]
<a href=#36 id=36 data-nosnippet>36</a></span><span class="kw">pub fn </span>is_hex_digit(chr: u8) -&gt; bool {
<a href=#37 id=37 data-nosnippet>37</a> <span class="macro">matches!</span>(chr, <span class="number">0x30</span>..=<span class="number">0x39 </span>| <span class="number">0x41</span>..=<span class="number">0x46 </span>| <span class="number">0x61</span>..=<span class="number">0x66</span>)
<a href=#38 id=38 data-nosnippet>38</a>}
<a href=#39 id=39 data-nosnippet>39</a>
<a href=#40 id=40 data-nosnippet>40</a><span class="attr">#[inline]
<a href=#41 id=41 data-nosnippet>41</a>#[doc(hidden)]
<a href=#42 id=42 data-nosnippet>42</a>#[deprecated(since = <span class="string">"8.0.0"</span>, note = <span class="string">"Replaced with `AsChar::is_oct_digit`"</span>)]
<a href=#43 id=43 data-nosnippet>43</a></span><span class="kw">pub fn </span>is_oct_digit(chr: u8) -&gt; bool {
<a href=#44 id=44 data-nosnippet>44</a> <span class="macro">matches!</span>(chr, <span class="number">0x30</span>..=<span class="number">0x37</span>)
<a href=#45 id=45 data-nosnippet>45</a>}
<a href=#46 id=46 data-nosnippet>46</a>
<a href=#47 id=47 data-nosnippet>47</a><span class="doccomment">/// Tests if byte is ASCII binary digit: 0-1
<a href=#48 id=48 data-nosnippet>48</a>///
<a href=#49 id=49 data-nosnippet>49</a>/// # Example
<a href=#50 id=50 data-nosnippet>50</a>///
<a href=#51 id=51 data-nosnippet>51</a>/// ```
<a href=#52 id=52 data-nosnippet>52</a>/// # use nom::character::is_bin_digit;
<a href=#53 id=53 data-nosnippet>53</a>/// assert_eq!(is_bin_digit(b'a'), false);
<a href=#54 id=54 data-nosnippet>54</a>/// assert_eq!(is_bin_digit(b'2'), false);
<a href=#55 id=55 data-nosnippet>55</a>/// assert_eq!(is_bin_digit(b'0'), true);
<a href=#56 id=56 data-nosnippet>56</a>/// assert_eq!(is_bin_digit(b'1'), true);
<a href=#57 id=57 data-nosnippet>57</a>/// ```
<a href=#58 id=58 data-nosnippet>58</a></span><span class="attr">#[inline]
<a href=#59 id=59 data-nosnippet>59</a></span><span class="kw">pub fn </span>is_bin_digit(chr: u8) -&gt; bool {
<a href=#60 id=60 data-nosnippet>60</a> <span class="macro">matches!</span>(chr, <span class="number">0x30</span>..=<span class="number">0x31</span>)
<a href=#61 id=61 data-nosnippet>61</a>}
<a href=#62 id=62 data-nosnippet>62</a>
<a href=#63 id=63 data-nosnippet>63</a><span class="attr">#[inline]
<a href=#64 id=64 data-nosnippet>64</a>#[doc(hidden)]
<a href=#65 id=65 data-nosnippet>65</a>#[deprecated(since = <span class="string">"8.0.0"</span>, note = <span class="string">"Replaced with `AsChar::is_alphanum`"</span>)]
<a href=#66 id=66 data-nosnippet>66</a></span><span class="kw">pub fn </span>is_alphanumeric(chr: u8) -&gt; bool {
<a href=#67 id=67 data-nosnippet>67</a> AsChar::is_alphanum(chr)
<a href=#68 id=68 data-nosnippet>68</a>}
<a href=#69 id=69 data-nosnippet>69</a>
<a href=#70 id=70 data-nosnippet>70</a><span class="attr">#[inline]
<a href=#71 id=71 data-nosnippet>71</a>#[doc(hidden)]
<a href=#72 id=72 data-nosnippet>72</a>#[deprecated(since = <span class="string">"8.0.0"</span>, note = <span class="string">"Replaced with `AsChar::is_space`"</span>)]
<a href=#73 id=73 data-nosnippet>73</a></span><span class="kw">pub fn </span>is_space(chr: u8) -&gt; bool {
<a href=#74 id=74 data-nosnippet>74</a> chr == <span class="string">b' ' </span>|| chr == <span class="string">b'\t'
<a href=#75 id=75 data-nosnippet>75</a></span>}
<a href=#76 id=76 data-nosnippet>76</a>
<a href=#77 id=77 data-nosnippet>77</a><span class="attr">#[inline]
<a href=#78 id=78 data-nosnippet>78</a>#[doc(hidden)]
<a href=#79 id=79 data-nosnippet>79</a>#[deprecated(since = <span class="string">"8.0.0"</span>, note = <span class="string">"Replaced with `AsChar::is_newline`"</span>)]
<a href=#80 id=80 data-nosnippet>80</a></span><span class="kw">pub fn </span>is_newline(chr: u8) -&gt; bool {
<a href=#81 id=81 data-nosnippet>81</a> chr == <span class="string">b'\n'
<a href=#82 id=82 data-nosnippet>82</a></span>}
<a href=#83 id=83 data-nosnippet>83</a>
<a href=#84 id=84 data-nosnippet>84</a><span class="doccomment">/// Recognizes one character.
<a href=#85 id=85 data-nosnippet>85</a>///
<a href=#86 id=86 data-nosnippet>86</a>/// # Example
<a href=#87 id=87 data-nosnippet>87</a>///
<a href=#88 id=88 data-nosnippet>88</a>/// ```
<a href=#89 id=89 data-nosnippet>89</a>/// # use nom::{Err, error::{ErrorKind, Error}, Needed, IResult};
<a href=#90 id=90 data-nosnippet>90</a>/// # use nom::character::streaming::char;
<a href=#91 id=91 data-nosnippet>91</a>/// fn parser(i: &amp;str) -&gt; IResult&lt;&amp;str, char&gt; {
<a href=#92 id=92 data-nosnippet>92</a>/// char('a')(i)
<a href=#93 id=93 data-nosnippet>93</a>/// }
<a href=#94 id=94 data-nosnippet>94</a>/// assert_eq!(parser("abc"), Ok(("bc", 'a')));
<a href=#95 id=95 data-nosnippet>95</a>/// assert_eq!(parser("bc"), Err(Err::Error(Error::new("bc", ErrorKind::Char))));
<a href=#96 id=96 data-nosnippet>96</a>/// assert_eq!(parser(""), Err(Err::Incomplete(Needed::new(1))));
<a href=#97 id=97 data-nosnippet>97</a>/// ```
<a href=#98 id=98 data-nosnippet>98</a></span><span class="kw">pub fn </span>char&lt;I, Error: ParseError&lt;I&gt;&gt;(c: char) -&gt; <span class="kw">impl </span>Parser&lt;I, Output = char, Error = Error&gt;
<a href=#99 id=99 data-nosnippet>99</a><span class="kw">where
<a href=#100 id=100 data-nosnippet>100</a> </span>I: Input,
<a href=#101 id=101 data-nosnippet>101</a> &lt;I <span class="kw">as </span>Input&gt;::Item: AsChar,
<a href=#102 id=102 data-nosnippet>102</a>{
<a href=#103 id=103 data-nosnippet>103</a> Char { c, e: PhantomData }
<a href=#104 id=104 data-nosnippet>104</a>}
<a href=#105 id=105 data-nosnippet>105</a>
<a href=#106 id=106 data-nosnippet>106</a><span class="doccomment">/// Parser implementation for [char()]
<a href=#107 id=107 data-nosnippet>107</a></span><span class="kw">pub struct </span>Char&lt;E&gt; {
<a href=#108 id=108 data-nosnippet>108</a> c: char,
<a href=#109 id=109 data-nosnippet>109</a> e: PhantomData&lt;E&gt;,
<a href=#110 id=110 data-nosnippet>110</a>}
<a href=#111 id=111 data-nosnippet>111</a>
<a href=#112 id=112 data-nosnippet>112</a><span class="kw">impl</span>&lt;I, Error: ParseError&lt;I&gt;&gt; Parser&lt;I&gt; <span class="kw">for </span>Char&lt;Error&gt;
<a href=#113 id=113 data-nosnippet>113</a><span class="kw">where
<a href=#114 id=114 data-nosnippet>114</a> </span>I: Input,
<a href=#115 id=115 data-nosnippet>115</a> &lt;I <span class="kw">as </span>Input&gt;::Item: AsChar,
<a href=#116 id=116 data-nosnippet>116</a>{
<a href=#117 id=117 data-nosnippet>117</a> <span class="kw">type </span>Output = char;
<a href=#118 id=118 data-nosnippet>118</a> <span class="kw">type </span>Error = Error;
<a href=#119 id=119 data-nosnippet>119</a> <span class="attr">#[inline(always)]
<a href=#120 id=120 data-nosnippet>120</a> </span><span class="kw">fn </span>process&lt;OM: <span class="kw">crate</span>::OutputMode&gt;(
<a href=#121 id=121 data-nosnippet>121</a> <span class="kw-2">&amp;mut </span><span class="self">self</span>,
<a href=#122 id=122 data-nosnippet>122</a> i: I,
<a href=#123 id=123 data-nosnippet>123</a> ) -&gt; <span class="kw">crate</span>::PResult&lt;OM, I, <span class="self">Self</span>::Output, <span class="self">Self</span>::Error&gt; {
<a href=#124 id=124 data-nosnippet>124</a> <span class="kw">match </span>(i).iter_elements().next().map(|t| {
<a href=#125 id=125 data-nosnippet>125</a> <span class="kw">let </span>b = t.as_char() == <span class="self">self</span>.c;
<a href=#126 id=126 data-nosnippet>126</a> (<span class="kw-2">&amp;</span><span class="self">self</span>.c, b)
<a href=#127 id=127 data-nosnippet>127</a> }) {
<a href=#128 id=128 data-nosnippet>128</a> <span class="prelude-val">None </span>=&gt; {
<a href=#129 id=129 data-nosnippet>129</a> <span class="kw">if </span>OM::Incomplete::is_streaming() {
<a href=#130 id=130 data-nosnippet>130</a> <span class="prelude-val">Err</span>(Err::Incomplete(Needed::new(<span class="self">self</span>.c.len() - i.input_len())))
<a href=#131 id=131 data-nosnippet>131</a> } <span class="kw">else </span>{
<a href=#132 id=132 data-nosnippet>132</a> <span class="prelude-val">Err</span>(Err::Error(OM::Error::bind(|| Error::from_char(i, <span class="self">self</span>.c))))
<a href=#133 id=133 data-nosnippet>133</a> }
<a href=#134 id=134 data-nosnippet>134</a> }
<a href=#135 id=135 data-nosnippet>135</a> <span class="prelude-val">Some</span>((<span class="kw">_</span>, <span class="bool-val">false</span>)) =&gt; <span class="prelude-val">Err</span>(Err::Error(OM::Error::bind(|| Error::from_char(i, <span class="self">self</span>.c)))),
<a href=#136 id=136 data-nosnippet>136</a> <span class="prelude-val">Some</span>((c, <span class="bool-val">true</span>)) =&gt; <span class="prelude-val">Ok</span>((i.take_from(c.len()), OM::Output::bind(|| c.as_char()))),
<a href=#137 id=137 data-nosnippet>137</a> }
<a href=#138 id=138 data-nosnippet>138</a> }
<a href=#139 id=139 data-nosnippet>139</a>}
<a href=#140 id=140 data-nosnippet>140</a>
<a href=#141 id=141 data-nosnippet>141</a><span class="doccomment">/// Recognizes one character and checks that it satisfies a predicate
<a href=#142 id=142 data-nosnippet>142</a>///
<a href=#143 id=143 data-nosnippet>143</a>/// # Example
<a href=#144 id=144 data-nosnippet>144</a>///
<a href=#145 id=145 data-nosnippet>145</a>/// ```
<a href=#146 id=146 data-nosnippet>146</a>/// # use nom::{Err, error::{ErrorKind, Error}, Needed, IResult};
<a href=#147 id=147 data-nosnippet>147</a>/// # use nom::character::complete::satisfy;
<a href=#148 id=148 data-nosnippet>148</a>/// fn parser(i: &amp;str) -&gt; IResult&lt;&amp;str, char&gt; {
<a href=#149 id=149 data-nosnippet>149</a>/// satisfy(|c| c == 'a' || c == 'b')(i)
<a href=#150 id=150 data-nosnippet>150</a>/// }
<a href=#151 id=151 data-nosnippet>151</a>/// assert_eq!(parser("abc"), Ok(("bc", 'a')));
<a href=#152 id=152 data-nosnippet>152</a>/// assert_eq!(parser("cd"), Err(Err::Error(Error::new("cd", ErrorKind::Satisfy))));
<a href=#153 id=153 data-nosnippet>153</a>/// assert_eq!(parser(""), Err(Err::Error(Error::new("", ErrorKind::Satisfy))));
<a href=#154 id=154 data-nosnippet>154</a>/// ```
<a href=#155 id=155 data-nosnippet>155</a></span><span class="kw">pub fn </span>satisfy&lt;F, I, Error: ParseError&lt;I&gt;&gt;(
<a href=#156 id=156 data-nosnippet>156</a> predicate: F,
<a href=#157 id=157 data-nosnippet>157</a>) -&gt; <span class="kw">impl </span>Parser&lt;I, Output = char, Error = Error&gt;
<a href=#158 id=158 data-nosnippet>158</a><span class="kw">where
<a href=#159 id=159 data-nosnippet>159</a> </span>I: Input,
<a href=#160 id=160 data-nosnippet>160</a> &lt;I <span class="kw">as </span>Input&gt;::Item: AsChar,
<a href=#161 id=161 data-nosnippet>161</a> F: Fn(char) -&gt; bool,
<a href=#162 id=162 data-nosnippet>162</a>{
<a href=#163 id=163 data-nosnippet>163</a> Satisfy {
<a href=#164 id=164 data-nosnippet>164</a> predicate,
<a href=#165 id=165 data-nosnippet>165</a> make_error: |i: I| Error::from_error_kind(i, ErrorKind::Satisfy),
<a href=#166 id=166 data-nosnippet>166</a> }
<a href=#167 id=167 data-nosnippet>167</a>}
<a href=#168 id=168 data-nosnippet>168</a>
<a href=#169 id=169 data-nosnippet>169</a><span class="doccomment">/// Parser implementation for [satisfy]
<a href=#170 id=170 data-nosnippet>170</a></span><span class="kw">pub struct </span>Satisfy&lt;F, MakeError&gt; {
<a href=#171 id=171 data-nosnippet>171</a> predicate: F,
<a href=#172 id=172 data-nosnippet>172</a> make_error: MakeError,
<a href=#173 id=173 data-nosnippet>173</a>}
<a href=#174 id=174 data-nosnippet>174</a>
<a href=#175 id=175 data-nosnippet>175</a><span class="kw">impl</span>&lt;I, Error: ParseError&lt;I&gt;, F, MakeError&gt; Parser&lt;I&gt; <span class="kw">for </span>Satisfy&lt;F, MakeError&gt;
<a href=#176 id=176 data-nosnippet>176</a><span class="kw">where
<a href=#177 id=177 data-nosnippet>177</a> </span>I: Input,
<a href=#178 id=178 data-nosnippet>178</a> &lt;I <span class="kw">as </span>Input&gt;::Item: AsChar,
<a href=#179 id=179 data-nosnippet>179</a> F: Fn(char) -&gt; bool,
<a href=#180 id=180 data-nosnippet>180</a> MakeError: Fn(I) -&gt; Error,
<a href=#181 id=181 data-nosnippet>181</a>{
<a href=#182 id=182 data-nosnippet>182</a> <span class="kw">type </span>Output = char;
<a href=#183 id=183 data-nosnippet>183</a> <span class="kw">type </span>Error = Error;
<a href=#184 id=184 data-nosnippet>184</a>
<a href=#185 id=185 data-nosnippet>185</a> <span class="attr">#[inline(always)]
<a href=#186 id=186 data-nosnippet>186</a> </span><span class="kw">fn </span>process&lt;OM: <span class="kw">crate</span>::OutputMode&gt;(
<a href=#187 id=187 data-nosnippet>187</a> <span class="kw-2">&amp;mut </span><span class="self">self</span>,
<a href=#188 id=188 data-nosnippet>188</a> i: I,
<a href=#189 id=189 data-nosnippet>189</a> ) -&gt; <span class="kw">crate</span>::PResult&lt;OM, I, <span class="self">Self</span>::Output, <span class="self">Self</span>::Error&gt; {
<a href=#190 id=190 data-nosnippet>190</a> <span class="kw">match </span>(i).iter_elements().next().map(|t| {
<a href=#191 id=191 data-nosnippet>191</a> <span class="kw">let </span>c = t.as_char();
<a href=#192 id=192 data-nosnippet>192</a> <span class="kw">let </span>b = (<span class="self">self</span>.predicate)(c);
<a href=#193 id=193 data-nosnippet>193</a> (c, b)
<a href=#194 id=194 data-nosnippet>194</a> }) {
<a href=#195 id=195 data-nosnippet>195</a> <span class="prelude-val">None </span>=&gt; {
<a href=#196 id=196 data-nosnippet>196</a> <span class="kw">if </span>OM::Incomplete::is_streaming() {
<a href=#197 id=197 data-nosnippet>197</a> <span class="prelude-val">Err</span>(Err::Incomplete(Needed::Unknown))
<a href=#198 id=198 data-nosnippet>198</a> } <span class="kw">else </span>{
<a href=#199 id=199 data-nosnippet>199</a> <span class="prelude-val">Err</span>(Err::Error(OM::Error::bind(|| (<span class="self">self</span>.make_error)(i))))
<a href=#200 id=200 data-nosnippet>200</a> }
<a href=#201 id=201 data-nosnippet>201</a> }
<a href=#202 id=202 data-nosnippet>202</a> <span class="prelude-val">Some</span>((<span class="kw">_</span>, <span class="bool-val">false</span>)) =&gt; <span class="prelude-val">Err</span>(Err::Error(OM::Error::bind(|| (<span class="self">self</span>.make_error)(i)))),
<a href=#203 id=203 data-nosnippet>203</a> <span class="prelude-val">Some</span>((c, <span class="bool-val">true</span>)) =&gt; <span class="prelude-val">Ok</span>((i.take_from(c.len()), OM::Output::bind(|| c.as_char()))),
<a href=#204 id=204 data-nosnippet>204</a> }
<a href=#205 id=205 data-nosnippet>205</a> }
<a href=#206 id=206 data-nosnippet>206</a>}
<a href=#207 id=207 data-nosnippet>207</a>
<a href=#208 id=208 data-nosnippet>208</a><span class="doccomment">/// Recognizes one of the provided characters.
<a href=#209 id=209 data-nosnippet>209</a>///
<a href=#210 id=210 data-nosnippet>210</a>/// # Example
<a href=#211 id=211 data-nosnippet>211</a>///
<a href=#212 id=212 data-nosnippet>212</a>/// ```
<a href=#213 id=213 data-nosnippet>213</a>/// # use nom::{Err, error::ErrorKind};
<a href=#214 id=214 data-nosnippet>214</a>/// # use nom::character::complete::one_of;
<a href=#215 id=215 data-nosnippet>215</a>/// assert_eq!(one_of::&lt;_, _, (&amp;str, ErrorKind)&gt;("abc")("b"), Ok(("", 'b')));
<a href=#216 id=216 data-nosnippet>216</a>/// assert_eq!(one_of::&lt;_, _, (&amp;str, ErrorKind)&gt;("a")("bc"), Err(Err::Error(("bc", ErrorKind::OneOf))));
<a href=#217 id=217 data-nosnippet>217</a>/// assert_eq!(one_of::&lt;_, _, (&amp;str, ErrorKind)&gt;("a")(""), Err(Err::Error(("", ErrorKind::OneOf))));
<a href=#218 id=218 data-nosnippet>218</a>/// ```
<a href=#219 id=219 data-nosnippet>219</a></span><span class="kw">pub fn </span>one_of&lt;I, T, Error: ParseError&lt;I&gt;&gt;(list: T) -&gt; <span class="kw">impl </span>Parser&lt;I, Output = char, Error = Error&gt;
<a href=#220 id=220 data-nosnippet>220</a><span class="kw">where
<a href=#221 id=221 data-nosnippet>221</a> </span>I: Input,
<a href=#222 id=222 data-nosnippet>222</a> &lt;I <span class="kw">as </span>Input&gt;::Item: AsChar,
<a href=#223 id=223 data-nosnippet>223</a> T: FindToken&lt;char&gt;,
<a href=#224 id=224 data-nosnippet>224</a>{
<a href=#225 id=225 data-nosnippet>225</a> Satisfy {
<a href=#226 id=226 data-nosnippet>226</a> predicate: <span class="kw">move </span>|c: char| list.find_token(c),
<a href=#227 id=227 data-nosnippet>227</a> make_error: <span class="kw">move </span>|i| Error::from_error_kind(i, ErrorKind::OneOf),
<a href=#228 id=228 data-nosnippet>228</a> }
<a href=#229 id=229 data-nosnippet>229</a>}
<a href=#230 id=230 data-nosnippet>230</a>
<a href=#231 id=231 data-nosnippet>231</a><span class="comment">//. Recognizes a character that is not in the provided characters.
<a href=#232 id=232 data-nosnippet>232</a></span><span class="doccomment">///
<a href=#233 id=233 data-nosnippet>233</a>/// # Example
<a href=#234 id=234 data-nosnippet>234</a>///
<a href=#235 id=235 data-nosnippet>235</a>/// ```
<a href=#236 id=236 data-nosnippet>236</a>/// # use nom::{Err, error::ErrorKind, Needed};
<a href=#237 id=237 data-nosnippet>237</a>/// # use nom::character::streaming::none_of;
<a href=#238 id=238 data-nosnippet>238</a>/// assert_eq!(none_of::&lt;_, _, (_, ErrorKind)&gt;("abc")("z"), Ok(("", 'z')));
<a href=#239 id=239 data-nosnippet>239</a>/// assert_eq!(none_of::&lt;_, _, (_, ErrorKind)&gt;("ab")("a"), Err(Err::Error(("a", ErrorKind::NoneOf))));
<a href=#240 id=240 data-nosnippet>240</a>/// assert_eq!(none_of::&lt;_, _, (_, ErrorKind)&gt;("a")(""), Err(Err::Incomplete(Needed::Unknown)));
<a href=#241 id=241 data-nosnippet>241</a>/// ```
<a href=#242 id=242 data-nosnippet>242</a></span><span class="kw">pub fn </span>none_of&lt;I, T, Error: ParseError&lt;I&gt;&gt;(list: T) -&gt; <span class="kw">impl </span>Parser&lt;I, Output = char, Error = Error&gt;
<a href=#243 id=243 data-nosnippet>243</a><span class="kw">where
<a href=#244 id=244 data-nosnippet>244</a> </span>I: Input,
<a href=#245 id=245 data-nosnippet>245</a> &lt;I <span class="kw">as </span>Input&gt;::Item: AsChar,
<a href=#246 id=246 data-nosnippet>246</a> T: FindToken&lt;char&gt;,
<a href=#247 id=247 data-nosnippet>247</a>{
<a href=#248 id=248 data-nosnippet>248</a> Satisfy {
<a href=#249 id=249 data-nosnippet>249</a> predicate: <span class="kw">move </span>|c: char| !list.find_token(c),
<a href=#250 id=250 data-nosnippet>250</a> make_error: <span class="kw">move </span>|i| Error::from_error_kind(i, ErrorKind::NoneOf),
<a href=#251 id=251 data-nosnippet>251</a> }
<a href=#252 id=252 data-nosnippet>252</a>}
<a href=#253 id=253 data-nosnippet>253</a>
<a href=#254 id=254 data-nosnippet>254</a><span class="comment">// Matches one byte as a character. Note that the input type will
<a href=#255 id=255 data-nosnippet>255</a></span><span class="doccomment">/// accept a `str`, but not a `&amp;[u8]`, unlike many other nom parsers.
<a href=#256 id=256 data-nosnippet>256</a>///
<a href=#257 id=257 data-nosnippet>257</a>/// # Example
<a href=#258 id=258 data-nosnippet>258</a>///
<a href=#259 id=259 data-nosnippet>259</a>/// ```
<a href=#260 id=260 data-nosnippet>260</a>/// # use nom::{character::complete::anychar, Err, error::{Error, ErrorKind}, IResult};
<a href=#261 id=261 data-nosnippet>261</a>/// fn parser(input: &amp;str) -&gt; IResult&lt;&amp;str, char&gt; {
<a href=#262 id=262 data-nosnippet>262</a>/// anychar(input)
<a href=#263 id=263 data-nosnippet>263</a>/// }
<a href=#264 id=264 data-nosnippet>264</a>///
<a href=#265 id=265 data-nosnippet>265</a>/// assert_eq!(parser("abc"), Ok(("bc",'a')));
<a href=#266 id=266 data-nosnippet>266</a>/// assert_eq!(parser(""), Err(Err::Error(Error::new("", ErrorKind::Eof))));
<a href=#267 id=267 data-nosnippet>267</a>/// ```
<a href=#268 id=268 data-nosnippet>268</a></span><span class="kw">pub fn </span>anychar&lt;T, E: ParseError&lt;T&gt;&gt;(input: T) -&gt; IResult&lt;T, char, E&gt;
<a href=#269 id=269 data-nosnippet>269</a><span class="kw">where
<a href=#270 id=270 data-nosnippet>270</a> </span>T: Input,
<a href=#271 id=271 data-nosnippet>271</a> &lt;T <span class="kw">as </span>Input&gt;::Item: AsChar,
<a href=#272 id=272 data-nosnippet>272</a>{
<a href=#273 id=273 data-nosnippet>273</a> <span class="kw">let </span><span class="kw-2">mut </span>it = input.iter_elements();
<a href=#274 id=274 data-nosnippet>274</a> <span class="kw">match </span>it.next() {
<a href=#275 id=275 data-nosnippet>275</a> <span class="prelude-val">None </span>=&gt; <span class="prelude-val">Err</span>(Err::Error(E::from_error_kind(input, ErrorKind::Eof))),
<a href=#276 id=276 data-nosnippet>276</a> <span class="prelude-val">Some</span>(c) =&gt; <span class="prelude-val">Ok</span>((input.take_from(c.len()), c.as_char())),
<a href=#277 id=277 data-nosnippet>277</a> }
<a href=#278 id=278 data-nosnippet>278</a>}
<a href=#279 id=279 data-nosnippet>279</a>
<a href=#280 id=280 data-nosnippet>280</a><span class="doccomment">/// Parser implementation for char
<a href=#281 id=281 data-nosnippet>281</a></span><span class="kw">pub struct </span>AnyChar&lt;E&gt; {
<a href=#282 id=282 data-nosnippet>282</a> e: PhantomData&lt;E&gt;,
<a href=#283 id=283 data-nosnippet>283</a>}
<a href=#284 id=284 data-nosnippet>284</a>
<a href=#285 id=285 data-nosnippet>285</a><span class="kw">impl</span>&lt;I, Error: ParseError&lt;I&gt;&gt; Parser&lt;I&gt; <span class="kw">for </span>AnyChar&lt;Error&gt;
<a href=#286 id=286 data-nosnippet>286</a><span class="kw">where
<a href=#287 id=287 data-nosnippet>287</a> </span>I: Input,
<a href=#288 id=288 data-nosnippet>288</a> &lt;I <span class="kw">as </span>Input&gt;::Item: AsChar,
<a href=#289 id=289 data-nosnippet>289</a>{
<a href=#290 id=290 data-nosnippet>290</a> <span class="kw">type </span>Output = char;
<a href=#291 id=291 data-nosnippet>291</a> <span class="kw">type </span>Error = Error;
<a href=#292 id=292 data-nosnippet>292</a>
<a href=#293 id=293 data-nosnippet>293</a> <span class="kw">fn </span>process&lt;OM: <span class="kw">crate</span>::OutputMode&gt;(
<a href=#294 id=294 data-nosnippet>294</a> <span class="kw-2">&amp;mut </span><span class="self">self</span>,
<a href=#295 id=295 data-nosnippet>295</a> i: I,
<a href=#296 id=296 data-nosnippet>296</a> ) -&gt; <span class="kw">crate</span>::PResult&lt;OM, I, <span class="self">Self</span>::Output, <span class="self">Self</span>::Error&gt; {
<a href=#297 id=297 data-nosnippet>297</a> <span class="kw">match </span>(i).iter_elements().next() {
<a href=#298 id=298 data-nosnippet>298</a> <span class="prelude-val">None </span>=&gt; {
<a href=#299 id=299 data-nosnippet>299</a> <span class="kw">if </span>OM::Incomplete::is_streaming() {
<a href=#300 id=300 data-nosnippet>300</a> <span class="prelude-val">Err</span>(Err::Incomplete(Needed::new(<span class="number">1</span>)))
<a href=#301 id=301 data-nosnippet>301</a> } <span class="kw">else </span>{
<a href=#302 id=302 data-nosnippet>302</a> <span class="prelude-val">Err</span>(Err::Error(OM::Error::bind(|| {
<a href=#303 id=303 data-nosnippet>303</a> Error::from_error_kind(i, ErrorKind::Eof)
<a href=#304 id=304 data-nosnippet>304</a> })))
<a href=#305 id=305 data-nosnippet>305</a> }
<a href=#306 id=306 data-nosnippet>306</a> }
<a href=#307 id=307 data-nosnippet>307</a> <span class="prelude-val">Some</span>(c) =&gt; <span class="prelude-val">Ok</span>((i.take_from(c.len()), OM::Output::bind(|| c.as_char()))),
<a href=#308 id=308 data-nosnippet>308</a> }
<a href=#309 id=309 data-nosnippet>309</a> }
<a href=#310 id=310 data-nosnippet>310</a>}
<a href=#311 id=311 data-nosnippet>311</a>
<a href=#312 id=312 data-nosnippet>312</a><span class="doccomment">/// Recognizes one or more ASCII numerical characters: 0-9
<a href=#313 id=313 data-nosnippet>313</a>///
<a href=#314 id=314 data-nosnippet>314</a>/// *Streaming version*: Will return `Err(nom::Err::Incomplete(_))` if there's not enough input data,
<a href=#315 id=315 data-nosnippet>315</a>/// or if no terminating token is found (a non digit character).
<a href=#316 id=316 data-nosnippet>316</a>/// # Example
<a href=#317 id=317 data-nosnippet>317</a>///
<a href=#318 id=318 data-nosnippet>318</a>/// ```
<a href=#319 id=319 data-nosnippet>319</a>/// # use nom::{Err, error::ErrorKind, IResult, Needed};
<a href=#320 id=320 data-nosnippet>320</a>/// # use nom::character::streaming::digit1;
<a href=#321 id=321 data-nosnippet>321</a>/// assert_eq!(digit1::&lt;_, (_, ErrorKind)&gt;("21c"), Ok(("c", "21")));
<a href=#322 id=322 data-nosnippet>322</a>/// assert_eq!(digit1::&lt;_, (_, ErrorKind)&gt;("c1"), Err(Err::Error(("c1", ErrorKind::Digit))));
<a href=#323 id=323 data-nosnippet>323</a>/// assert_eq!(digit1::&lt;_, (_, ErrorKind)&gt;(""), Err(Err::Incomplete(Needed::new(1))));
<a href=#324 id=324 data-nosnippet>324</a>/// ```
<a href=#325 id=325 data-nosnippet>325</a></span><span class="kw">pub fn </span>digit1&lt;T, E: ParseError&lt;T&gt;&gt;() -&gt; <span class="kw">impl </span>Parser&lt;T, Output = T, Error = E&gt;
<a href=#326 id=326 data-nosnippet>326</a><span class="kw">where
<a href=#327 id=327 data-nosnippet>327</a> </span>T: Input,
<a href=#328 id=328 data-nosnippet>328</a> &lt;T <span class="kw">as </span>Input&gt;::Item: AsChar,
<a href=#329 id=329 data-nosnippet>329</a>{
<a href=#330 id=330 data-nosnippet>330</a> Digit1 { e: PhantomData }
<a href=#331 id=331 data-nosnippet>331</a>}
<a href=#332 id=332 data-nosnippet>332</a>
<a href=#333 id=333 data-nosnippet>333</a><span class="doccomment">/// Parser implementation for [digit1]
<a href=#334 id=334 data-nosnippet>334</a></span><span class="kw">pub struct </span>Digit1&lt;E&gt; {
<a href=#335 id=335 data-nosnippet>335</a> e: PhantomData&lt;E&gt;,
<a href=#336 id=336 data-nosnippet>336</a>}
<a href=#337 id=337 data-nosnippet>337</a>
<a href=#338 id=338 data-nosnippet>338</a><span class="kw">impl</span>&lt;I: Input, E: ParseError&lt;I&gt;&gt; Parser&lt;I&gt; <span class="kw">for </span>Digit1&lt;E&gt;
<a href=#339 id=339 data-nosnippet>339</a><span class="kw">where
<a href=#340 id=340 data-nosnippet>340</a> </span>&lt;I <span class="kw">as </span>Input&gt;::Item: AsChar,
<a href=#341 id=341 data-nosnippet>341</a>{
<a href=#342 id=342 data-nosnippet>342</a> <span class="kw">type </span>Output = I;
<a href=#343 id=343 data-nosnippet>343</a>
<a href=#344 id=344 data-nosnippet>344</a> <span class="kw">type </span>Error = E;
<a href=#345 id=345 data-nosnippet>345</a>
<a href=#346 id=346 data-nosnippet>346</a> <span class="attr">#[inline]
<a href=#347 id=347 data-nosnippet>347</a> </span><span class="kw">fn </span>process&lt;OM: <span class="kw">crate</span>::OutputMode&gt;(
<a href=#348 id=348 data-nosnippet>348</a> <span class="kw-2">&amp;mut </span><span class="self">self</span>,
<a href=#349 id=349 data-nosnippet>349</a> input: I,
<a href=#350 id=350 data-nosnippet>350</a> ) -&gt; <span class="kw">crate</span>::PResult&lt;OM, I, <span class="self">Self</span>::Output, <span class="self">Self</span>::Error&gt; {
<a href=#351 id=351 data-nosnippet>351</a> input.split_at_position_mode1::&lt;OM, <span class="kw">_</span>, <span class="kw">_</span>&gt;(|item| !item.is_dec_digit(), ErrorKind::Digit)
<a href=#352 id=352 data-nosnippet>352</a> }
<a href=#353 id=353 data-nosnippet>353</a>}
<a href=#354 id=354 data-nosnippet>354</a>
<a href=#355 id=355 data-nosnippet>355</a><span class="doccomment">/// Recognizes zero or more spaces, tabs, carriage returns and line feeds.
<a href=#356 id=356 data-nosnippet>356</a>///
<a href=#357 id=357 data-nosnippet>357</a>/// *Streaming version*: Will return `Err(nom::Err::Incomplete(_))` if there's not enough input data,
<a href=#358 id=358 data-nosnippet>358</a>/// or if no terminating token is found (a non space character).
<a href=#359 id=359 data-nosnippet>359</a>/// # Example
<a href=#360 id=360 data-nosnippet>360</a>///
<a href=#361 id=361 data-nosnippet>361</a>/// ```
<a href=#362 id=362 data-nosnippet>362</a>/// # use nom::{Err, error::ErrorKind, IResult, Needed};
<a href=#363 id=363 data-nosnippet>363</a>/// # use nom::character::streaming::multispace0;
<a href=#364 id=364 data-nosnippet>364</a>/// assert_eq!(multispace0::&lt;_, (_, ErrorKind)&gt;(" \t\n\r21c"), Ok(("21c", " \t\n\r")));
<a href=#365 id=365 data-nosnippet>365</a>/// assert_eq!(multispace0::&lt;_, (_, ErrorKind)&gt;("Z21c"), Ok(("Z21c", "")));
<a href=#366 id=366 data-nosnippet>366</a>/// assert_eq!(multispace0::&lt;_, (_, ErrorKind)&gt;(""), Err(Err::Incomplete(Needed::new(1))));
<a href=#367 id=367 data-nosnippet>367</a>/// ```
<a href=#368 id=368 data-nosnippet>368</a></span><span class="kw">pub fn </span>multispace0&lt;T, E: ParseError&lt;T&gt;&gt;() -&gt; <span class="kw">impl </span>Parser&lt;T, Output = T, Error = E&gt;
<a href=#369 id=369 data-nosnippet>369</a><span class="kw">where
<a href=#370 id=370 data-nosnippet>370</a> </span>T: Input,
<a href=#371 id=371 data-nosnippet>371</a> &lt;T <span class="kw">as </span>Input&gt;::Item: AsChar,
<a href=#372 id=372 data-nosnippet>372</a>{
<a href=#373 id=373 data-nosnippet>373</a> MultiSpace0 { e: PhantomData }
<a href=#374 id=374 data-nosnippet>374</a> <span class="comment">/*input.split_at_position(|item| {
<a href=#375 id=375 data-nosnippet>375</a> let c = item.as_char();
<a href=#376 id=376 data-nosnippet>376</a> !(c == ' ' || c == '\t' || c == '\r' || c == '\n')
<a href=#377 id=377 data-nosnippet>377</a> })*/
<a href=#378 id=378 data-nosnippet>378</a></span>}
<a href=#379 id=379 data-nosnippet>379</a>
<a href=#380 id=380 data-nosnippet>380</a><span class="doccomment">/// Parser implementation for [multispace0()]
<a href=#381 id=381 data-nosnippet>381</a></span><span class="kw">pub struct </span>MultiSpace0&lt;E&gt; {
<a href=#382 id=382 data-nosnippet>382</a> e: PhantomData&lt;E&gt;,
<a href=#383 id=383 data-nosnippet>383</a>}
<a href=#384 id=384 data-nosnippet>384</a>
<a href=#385 id=385 data-nosnippet>385</a><span class="kw">impl</span>&lt;I, Error: ParseError&lt;I&gt;&gt; Parser&lt;I&gt; <span class="kw">for </span>MultiSpace0&lt;Error&gt;
<a href=#386 id=386 data-nosnippet>386</a><span class="kw">where
<a href=#387 id=387 data-nosnippet>387</a> </span>I: Input,
<a href=#388 id=388 data-nosnippet>388</a> &lt;I <span class="kw">as </span>Input&gt;::Item: AsChar,
<a href=#389 id=389 data-nosnippet>389</a>{
<a href=#390 id=390 data-nosnippet>390</a> <span class="kw">type </span>Output = I;
<a href=#391 id=391 data-nosnippet>391</a> <span class="kw">type </span>Error = Error;
<a href=#392 id=392 data-nosnippet>392</a>
<a href=#393 id=393 data-nosnippet>393</a> <span class="kw">fn </span>process&lt;OM: <span class="kw">crate</span>::OutputMode&gt;(
<a href=#394 id=394 data-nosnippet>394</a> <span class="kw-2">&amp;mut </span><span class="self">self</span>,
<a href=#395 id=395 data-nosnippet>395</a> i: I,
<a href=#396 id=396 data-nosnippet>396</a> ) -&gt; <span class="kw">crate</span>::PResult&lt;OM, I, <span class="self">Self</span>::Output, <span class="self">Self</span>::Error&gt; {
<a href=#397 id=397 data-nosnippet>397</a> i.split_at_position_mode::&lt;OM, <span class="kw">_</span>, <span class="kw">_</span>&gt;(|item| {
<a href=#398 id=398 data-nosnippet>398</a> <span class="kw">let </span>c = item.as_char();
<a href=#399 id=399 data-nosnippet>399</a> !(c == <span class="string">' ' </span>|| c == <span class="string">'\t' </span>|| c == <span class="string">'\r' </span>|| c == <span class="string">'\n'</span>)
<a href=#400 id=400 data-nosnippet>400</a> })
<a href=#401 id=401 data-nosnippet>401</a> }
<a href=#402 id=402 data-nosnippet>402</a>}
</code></pre></div></section></main></body></html>
File diff suppressed because it is too large Load Diff
File diff suppressed because it is too large Load Diff
+803
View File
@@ -0,0 +1,803 @@
<!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 of the Rust file `/home/newkirk/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/nom-8.0.0/src/error.rs`."><title>error.rs - source</title><script>if(window.location.protocol!=="file:")document.head.insertAdjacentHTML("beforeend","SourceSerif4-Regular-6b053e98.ttf.woff2,FiraSans-Italic-81dc35de.woff2,FiraSans-Regular-0fe48ade.woff2,FiraSans-MediumItalic-ccf7e434.woff2,FiraSans-Medium-e1aa3f0a.woff2,SourceCodePro-Regular-8badfe75.ttf.woff2,SourceCodePro-Semibold-aa29a496.ttf.woff2".split(",").map(f=>`<link rel="preload" as="font" type="font/woff2"href="../../static.files/${f}">`).join(""))</script><link rel="stylesheet" href="../../static.files/normalize-9960930a.css"><link rel="stylesheet" href="../../static.files/rustdoc-ca0dd0c4.css"><meta name="rustdoc-vars" data-root-path="../../" data-static-root-path="../../static.files/" data-current-crate="nom" data-themes="" data-resource-suffix="" data-rustdoc-version="1.93.1 (01f6ddf75 2026-02-11) (Arch Linux rust 1:1.93.1-1)" data-channel="1.93.1" data-search-js="search-9e2438ea.js" data-stringdex-js="stringdex-a3946164.js" data-settings-js="settings-c38705f0.js" ><script src="../../static.files/storage-e2aeef58.js"></script><script defer src="../../static.files/src-script-813739b1.js"></script><script defer src="../../src-files.js"></script><script defer src="../../static.files/main-a410ff4d.js"></script><noscript><link rel="stylesheet" href="../../static.files/noscript-263c88ec.css"></noscript><link rel="alternate icon" type="image/png" href="../../static.files/favicon-32x32-eab170b8.png"><link rel="icon" type="image/svg+xml" href="../../static.files/favicon-044be391.svg"></head><body class="rustdoc src"><!--[if lte IE 11]><div class="warning">This old browser is unsupported and will most likely display funky things.</div><![endif]--><nav class="sidebar"><div class="src-sidebar-title"><h2>Files</h2></div></nav><div class="sidebar-resizer" title="Drag to resize sidebar"></div><main><section id="main-content" class="content"><div class="main-heading"><h1><div class="sub-heading">nom/</div>error.rs</h1><rustdoc-toolbar></rustdoc-toolbar></div><div class="example-wrap digits-3"><pre class="rust"><code><a href=#1 id=1 data-nosnippet>1</a><span class="doccomment">//! Error management
<a href=#2 id=2 data-nosnippet>2</a>//!
<a href=#3 id=3 data-nosnippet>3</a>//! Parsers are generic over their error type, requiring that it implements
<a href=#4 id=4 data-nosnippet>4</a>//! the `error::ParseError&lt;Input&gt;` trait.
<a href=#5 id=5 data-nosnippet>5</a>
<a href=#6 id=6 data-nosnippet>6</a></span><span class="kw">use </span><span class="kw">crate</span>::internal::{<span class="prelude-val">Err</span>, Mode, OutputMode, PResult, Parser};
<a href=#7 id=7 data-nosnippet>7</a><span class="kw">use </span><span class="kw">crate</span>::lib::std::fmt;
<a href=#8 id=8 data-nosnippet>8</a>
<a href=#9 id=9 data-nosnippet>9</a><span class="attr">#[cfg(feature = <span class="string">"alloc"</span>)]
<a href=#10 id=10 data-nosnippet>10</a></span><span class="kw">use </span><span class="kw">crate</span>::alloc::borrow::ToOwned;
<a href=#11 id=11 data-nosnippet>11</a>
<a href=#12 id=12 data-nosnippet>12</a><span class="attr">#[cfg(feature = <span class="string">"std"</span>)]
<a href=#13 id=13 data-nosnippet>13</a></span><span class="kw">use </span><span class="kw">crate</span>::internal::IResult;
<a href=#14 id=14 data-nosnippet>14</a>
<a href=#15 id=15 data-nosnippet>15</a><span class="doccomment">/// This trait must be implemented by the error type of a nom parser.
<a href=#16 id=16 data-nosnippet>16</a>///
<a href=#17 id=17 data-nosnippet>17</a>/// There are already implementations of it for `(Input, ErrorKind)`
<a href=#18 id=18 data-nosnippet>18</a>/// and `Error&lt;Input&gt;`.
<a href=#19 id=19 data-nosnippet>19</a>///
<a href=#20 id=20 data-nosnippet>20</a>/// It provides methods to create an error from some combinators,
<a href=#21 id=21 data-nosnippet>21</a>/// and combine existing errors in combinators like `alt`.
<a href=#22 id=22 data-nosnippet>22</a></span><span class="kw">pub trait </span>ParseError&lt;I&gt;: Sized {
<a href=#23 id=23 data-nosnippet>23</a> <span class="doccomment">/// Creates an error from the input position and an [ErrorKind]
<a href=#24 id=24 data-nosnippet>24</a> </span><span class="kw">fn </span>from_error_kind(input: I, kind: ErrorKind) -&gt; <span class="self">Self</span>;
<a href=#25 id=25 data-nosnippet>25</a>
<a href=#26 id=26 data-nosnippet>26</a> <span class="doccomment">/// Combines an existing error with a new one created from the input
<a href=#27 id=27 data-nosnippet>27</a> /// position and an [ErrorKind]. This is useful when backtracking
<a href=#28 id=28 data-nosnippet>28</a> /// through a parse tree, accumulating error context on the way
<a href=#29 id=29 data-nosnippet>29</a> </span><span class="kw">fn </span>append(input: I, kind: ErrorKind, other: <span class="self">Self</span>) -&gt; <span class="self">Self</span>;
<a href=#30 id=30 data-nosnippet>30</a>
<a href=#31 id=31 data-nosnippet>31</a> <span class="doccomment">/// Creates an error from an input position and an expected character
<a href=#32 id=32 data-nosnippet>32</a> </span><span class="kw">fn </span>from_char(input: I, <span class="kw">_</span>: char) -&gt; <span class="self">Self </span>{
<a href=#33 id=33 data-nosnippet>33</a> <span class="self">Self</span>::from_error_kind(input, ErrorKind::Char)
<a href=#34 id=34 data-nosnippet>34</a> }
<a href=#35 id=35 data-nosnippet>35</a>
<a href=#36 id=36 data-nosnippet>36</a> <span class="doccomment">/// Combines two existing errors. This function is used to compare errors
<a href=#37 id=37 data-nosnippet>37</a> /// generated in various branches of `alt`.
<a href=#38 id=38 data-nosnippet>38</a> </span><span class="kw">fn </span>or(<span class="self">self</span>, other: <span class="self">Self</span>) -&gt; <span class="self">Self </span>{
<a href=#39 id=39 data-nosnippet>39</a> other
<a href=#40 id=40 data-nosnippet>40</a> }
<a href=#41 id=41 data-nosnippet>41</a>}
<a href=#42 id=42 data-nosnippet>42</a>
<a href=#43 id=43 data-nosnippet>43</a><span class="doccomment">/// This trait is required by the `context` combinator to add a static string
<a href=#44 id=44 data-nosnippet>44</a>/// to an existing error
<a href=#45 id=45 data-nosnippet>45</a></span><span class="kw">pub trait </span>ContextError&lt;I&gt;: Sized {
<a href=#46 id=46 data-nosnippet>46</a> <span class="doccomment">/// Creates a new error from an input position, a static string and an existing error.
<a href=#47 id=47 data-nosnippet>47</a> /// This is used mainly in the [context] combinator, to add user friendly information
<a href=#48 id=48 data-nosnippet>48</a> /// to errors when backtracking through a parse tree
<a href=#49 id=49 data-nosnippet>49</a> </span><span class="kw">fn </span>add_context(_input: I, _ctx: <span class="kw-2">&amp;</span><span class="lifetime">'static </span>str, other: <span class="self">Self</span>) -&gt; <span class="self">Self </span>{
<a href=#50 id=50 data-nosnippet>50</a> other
<a href=#51 id=51 data-nosnippet>51</a> }
<a href=#52 id=52 data-nosnippet>52</a>}
<a href=#53 id=53 data-nosnippet>53</a>
<a href=#54 id=54 data-nosnippet>54</a><span class="doccomment">/// This trait is required by the `map_res` combinator to integrate
<a href=#55 id=55 data-nosnippet>55</a>/// error types from external functions, like [std::str::FromStr]
<a href=#56 id=56 data-nosnippet>56</a></span><span class="kw">pub trait </span>FromExternalError&lt;I, E&gt; {
<a href=#57 id=57 data-nosnippet>57</a> <span class="doccomment">/// Creates a new error from an input position, an [ErrorKind] indicating the
<a href=#58 id=58 data-nosnippet>58</a> /// wrapping parser, and an external error
<a href=#59 id=59 data-nosnippet>59</a> </span><span class="kw">fn </span>from_external_error(input: I, kind: ErrorKind, e: E) -&gt; <span class="self">Self</span>;
<a href=#60 id=60 data-nosnippet>60</a>}
<a href=#61 id=61 data-nosnippet>61</a>
<a href=#62 id=62 data-nosnippet>62</a><span class="doccomment">/// default error type, only contains the error's location and code
<a href=#63 id=63 data-nosnippet>63</a></span><span class="attr">#[derive(Clone, Debug, Eq, PartialEq)]
<a href=#64 id=64 data-nosnippet>64</a></span><span class="kw">pub struct </span>Error&lt;I&gt; {
<a href=#65 id=65 data-nosnippet>65</a> <span class="doccomment">/// position of the error in the input data
<a href=#66 id=66 data-nosnippet>66</a> </span><span class="kw">pub </span>input: I,
<a href=#67 id=67 data-nosnippet>67</a> <span class="doccomment">/// nom error code
<a href=#68 id=68 data-nosnippet>68</a> </span><span class="kw">pub </span>code: ErrorKind,
<a href=#69 id=69 data-nosnippet>69</a>}
<a href=#70 id=70 data-nosnippet>70</a>
<a href=#71 id=71 data-nosnippet>71</a><span class="kw">impl</span>&lt;I&gt; Error&lt;I&gt; {
<a href=#72 id=72 data-nosnippet>72</a> <span class="doccomment">/// creates a new basic error
<a href=#73 id=73 data-nosnippet>73</a> </span><span class="kw">pub fn </span>new(input: I, code: ErrorKind) -&gt; Error&lt;I&gt; {
<a href=#74 id=74 data-nosnippet>74</a> Error { input, code }
<a href=#75 id=75 data-nosnippet>75</a> }
<a href=#76 id=76 data-nosnippet>76</a>}
<a href=#77 id=77 data-nosnippet>77</a>
<a href=#78 id=78 data-nosnippet>78</a><span class="kw">impl</span>&lt;I&gt; ParseError&lt;I&gt; <span class="kw">for </span>Error&lt;I&gt; {
<a href=#79 id=79 data-nosnippet>79</a> <span class="kw">fn </span>from_error_kind(input: I, kind: ErrorKind) -&gt; <span class="self">Self </span>{
<a href=#80 id=80 data-nosnippet>80</a> Error { input, code: kind }
<a href=#81 id=81 data-nosnippet>81</a> }
<a href=#82 id=82 data-nosnippet>82</a>
<a href=#83 id=83 data-nosnippet>83</a> <span class="kw">fn </span>append(<span class="kw">_</span>: I, <span class="kw">_</span>: ErrorKind, other: <span class="self">Self</span>) -&gt; <span class="self">Self </span>{
<a href=#84 id=84 data-nosnippet>84</a> other
<a href=#85 id=85 data-nosnippet>85</a> }
<a href=#86 id=86 data-nosnippet>86</a>}
<a href=#87 id=87 data-nosnippet>87</a>
<a href=#88 id=88 data-nosnippet>88</a><span class="kw">impl</span>&lt;I&gt; ContextError&lt;I&gt; <span class="kw">for </span>Error&lt;I&gt; {}
<a href=#89 id=89 data-nosnippet>89</a>
<a href=#90 id=90 data-nosnippet>90</a><span class="kw">impl</span>&lt;I, E&gt; FromExternalError&lt;I, E&gt; <span class="kw">for </span>Error&lt;I&gt; {
<a href=#91 id=91 data-nosnippet>91</a> <span class="doccomment">/// Create a new error from an input position and an external error
<a href=#92 id=92 data-nosnippet>92</a> </span><span class="kw">fn </span>from_external_error(input: I, kind: ErrorKind, _e: E) -&gt; <span class="self">Self </span>{
<a href=#93 id=93 data-nosnippet>93</a> Error { input, code: kind }
<a href=#94 id=94 data-nosnippet>94</a> }
<a href=#95 id=95 data-nosnippet>95</a>}
<a href=#96 id=96 data-nosnippet>96</a>
<a href=#97 id=97 data-nosnippet>97</a><span class="doccomment">/// The Display implementation allows the std::error::Error implementation
<a href=#98 id=98 data-nosnippet>98</a></span><span class="kw">impl</span>&lt;I: fmt::Display&gt; fmt::Display <span class="kw">for </span>Error&lt;I&gt; {
<a href=#99 id=99 data-nosnippet>99</a> <span class="kw">fn </span>fmt(<span class="kw-2">&amp;</span><span class="self">self</span>, f: <span class="kw-2">&amp;mut </span>fmt::Formatter&lt;<span class="lifetime">'_</span>&gt;) -&gt; fmt::Result {
<a href=#100 id=100 data-nosnippet>100</a> <span class="macro">write!</span>(f, <span class="string">"error {:?} at: {}"</span>, <span class="self">self</span>.code, <span class="self">self</span>.input)
<a href=#101 id=101 data-nosnippet>101</a> }
<a href=#102 id=102 data-nosnippet>102</a>}
<a href=#103 id=103 data-nosnippet>103</a>
<a href=#104 id=104 data-nosnippet>104</a><span class="attr">#[cfg(feature = <span class="string">"alloc"</span>)]
<a href=#105 id=105 data-nosnippet>105</a></span><span class="kw">impl</span>&lt;I: ToOwned + <span class="question-mark">?</span>Sized&gt; Error&lt;<span class="kw-2">&amp;</span>I&gt; {
<a href=#106 id=106 data-nosnippet>106</a> <span class="doccomment">/// Converts `Error&lt;&amp;I&gt;` into `Error&lt;I::Owned&gt;` by cloning.
<a href=#107 id=107 data-nosnippet>107</a> </span><span class="kw">pub fn </span>cloned(<span class="self">self</span>) -&gt; Error&lt;I::Owned&gt; {
<a href=#108 id=108 data-nosnippet>108</a> Error {
<a href=#109 id=109 data-nosnippet>109</a> input: <span class="self">self</span>.input.to_owned(),
<a href=#110 id=110 data-nosnippet>110</a> code: <span class="self">self</span>.code,
<a href=#111 id=111 data-nosnippet>111</a> }
<a href=#112 id=112 data-nosnippet>112</a> }
<a href=#113 id=113 data-nosnippet>113</a>}
<a href=#114 id=114 data-nosnippet>114</a>
<a href=#115 id=115 data-nosnippet>115</a><span class="attr">#[cfg(feature = <span class="string">"alloc"</span>)]
<a href=#116 id=116 data-nosnippet>116</a></span><span class="kw">impl</span>&lt;I: ToOwned + <span class="question-mark">?</span>Sized&gt; Error&lt;<span class="kw-2">&amp;mut </span>I&gt; {
<a href=#117 id=117 data-nosnippet>117</a> <span class="doccomment">/// Converts `Error&lt;&amp;mut I&gt;` into `Error&lt;I::Owned&gt;` by cloning.
<a href=#118 id=118 data-nosnippet>118</a> </span><span class="kw">pub fn </span>cloned(<span class="self">self</span>) -&gt; Error&lt;I::Owned&gt; {
<a href=#119 id=119 data-nosnippet>119</a> Error {
<a href=#120 id=120 data-nosnippet>120</a> input: <span class="self">self</span>.input.to_owned(),
<a href=#121 id=121 data-nosnippet>121</a> code: <span class="self">self</span>.code,
<a href=#122 id=122 data-nosnippet>122</a> }
<a href=#123 id=123 data-nosnippet>123</a> }
<a href=#124 id=124 data-nosnippet>124</a>}
<a href=#125 id=125 data-nosnippet>125</a>
<a href=#126 id=126 data-nosnippet>126</a><span class="kw">impl</span>&lt;I: Copy&gt; Error&lt;<span class="kw-2">&amp;</span>I&gt; {
<a href=#127 id=127 data-nosnippet>127</a> <span class="doccomment">/// Converts `Error&lt;&amp;I&gt;` into `Error&lt;I&gt;` by copying.
<a href=#128 id=128 data-nosnippet>128</a> </span><span class="kw">pub fn </span>copied(<span class="self">self</span>) -&gt; Error&lt;I&gt; {
<a href=#129 id=129 data-nosnippet>129</a> Error {
<a href=#130 id=130 data-nosnippet>130</a> input: <span class="kw-2">*</span><span class="self">self</span>.input,
<a href=#131 id=131 data-nosnippet>131</a> code: <span class="self">self</span>.code,
<a href=#132 id=132 data-nosnippet>132</a> }
<a href=#133 id=133 data-nosnippet>133</a> }
<a href=#134 id=134 data-nosnippet>134</a>}
<a href=#135 id=135 data-nosnippet>135</a>
<a href=#136 id=136 data-nosnippet>136</a><span class="kw">impl</span>&lt;I: Copy&gt; Error&lt;<span class="kw-2">&amp;mut </span>I&gt; {
<a href=#137 id=137 data-nosnippet>137</a> <span class="doccomment">/// Converts `Error&lt;&amp;mut I&gt;` into `Error&lt;I&gt;` by copying.
<a href=#138 id=138 data-nosnippet>138</a> </span><span class="kw">pub fn </span>copied(<span class="self">self</span>) -&gt; Error&lt;I&gt; {
<a href=#139 id=139 data-nosnippet>139</a> Error {
<a href=#140 id=140 data-nosnippet>140</a> input: <span class="kw-2">*</span><span class="self">self</span>.input,
<a href=#141 id=141 data-nosnippet>141</a> code: <span class="self">self</span>.code,
<a href=#142 id=142 data-nosnippet>142</a> }
<a href=#143 id=143 data-nosnippet>143</a> }
<a href=#144 id=144 data-nosnippet>144</a>}
<a href=#145 id=145 data-nosnippet>145</a>
<a href=#146 id=146 data-nosnippet>146</a><span class="attr">#[cfg(feature = <span class="string">"std"</span>)]
<a href=#147 id=147 data-nosnippet>147</a></span><span class="kw">impl</span>&lt;I: fmt::Debug + fmt::Display&gt; std::error::Error <span class="kw">for </span>Error&lt;I&gt; {}
<a href=#148 id=148 data-nosnippet>148</a>
<a href=#149 id=149 data-nosnippet>149</a><span class="attr">#[cfg(feature = <span class="string">"alloc"</span>)]
<a href=#150 id=150 data-nosnippet>150</a>#[cfg_attr(feature = <span class="string">"docsrs"</span>, doc(cfg(feature = <span class="string">"alloc"</span>)))]
<a href=#151 id=151 data-nosnippet>151</a></span><span class="kw">impl </span>From&lt;Error&lt;<span class="kw-2">&amp;</span>[u8]&gt;&gt; <span class="kw">for </span>Error&lt;<span class="kw">crate</span>::lib::std::vec::Vec&lt;u8&gt;&gt; {
<a href=#152 id=152 data-nosnippet>152</a> <span class="kw">fn </span>from(value: Error&lt;<span class="kw-2">&amp;</span>[u8]&gt;) -&gt; <span class="self">Self </span>{
<a href=#153 id=153 data-nosnippet>153</a> Error {
<a href=#154 id=154 data-nosnippet>154</a> input: value.input.to_owned(),
<a href=#155 id=155 data-nosnippet>155</a> code: value.code,
<a href=#156 id=156 data-nosnippet>156</a> }
<a href=#157 id=157 data-nosnippet>157</a> }
<a href=#158 id=158 data-nosnippet>158</a>}
<a href=#159 id=159 data-nosnippet>159</a>
<a href=#160 id=160 data-nosnippet>160</a><span class="attr">#[cfg(feature = <span class="string">"alloc"</span>)]
<a href=#161 id=161 data-nosnippet>161</a>#[cfg_attr(feature = <span class="string">"docsrs"</span>, doc(cfg(feature = <span class="string">"alloc"</span>)))]
<a href=#162 id=162 data-nosnippet>162</a></span><span class="kw">impl </span>From&lt;Error&lt;<span class="kw-2">&amp;</span>str&gt;&gt; <span class="kw">for </span>Error&lt;<span class="kw">crate</span>::lib::std::string::String&gt; {
<a href=#163 id=163 data-nosnippet>163</a> <span class="kw">fn </span>from(value: Error&lt;<span class="kw-2">&amp;</span>str&gt;) -&gt; <span class="self">Self </span>{
<a href=#164 id=164 data-nosnippet>164</a> Error {
<a href=#165 id=165 data-nosnippet>165</a> input: value.input.to_owned(),
<a href=#166 id=166 data-nosnippet>166</a> code: value.code,
<a href=#167 id=167 data-nosnippet>167</a> }
<a href=#168 id=168 data-nosnippet>168</a> }
<a href=#169 id=169 data-nosnippet>169</a>}
<a href=#170 id=170 data-nosnippet>170</a>
<a href=#171 id=171 data-nosnippet>171</a><span class="comment">// for backward compatibility, keep those trait implementations
<a href=#172 id=172 data-nosnippet>172</a>// for the previously used error type
<a href=#173 id=173 data-nosnippet>173</a></span><span class="kw">impl</span>&lt;I&gt; ParseError&lt;I&gt; <span class="kw">for </span>(I, ErrorKind) {
<a href=#174 id=174 data-nosnippet>174</a> <span class="kw">fn </span>from_error_kind(input: I, kind: ErrorKind) -&gt; <span class="self">Self </span>{
<a href=#175 id=175 data-nosnippet>175</a> (input, kind)
<a href=#176 id=176 data-nosnippet>176</a> }
<a href=#177 id=177 data-nosnippet>177</a>
<a href=#178 id=178 data-nosnippet>178</a> <span class="kw">fn </span>append(<span class="kw">_</span>: I, <span class="kw">_</span>: ErrorKind, other: <span class="self">Self</span>) -&gt; <span class="self">Self </span>{
<a href=#179 id=179 data-nosnippet>179</a> other
<a href=#180 id=180 data-nosnippet>180</a> }
<a href=#181 id=181 data-nosnippet>181</a>}
<a href=#182 id=182 data-nosnippet>182</a>
<a href=#183 id=183 data-nosnippet>183</a><span class="kw">impl</span>&lt;I&gt; ContextError&lt;I&gt; <span class="kw">for </span>(I, ErrorKind) {}
<a href=#184 id=184 data-nosnippet>184</a>
<a href=#185 id=185 data-nosnippet>185</a><span class="kw">impl</span>&lt;I, E&gt; FromExternalError&lt;I, E&gt; <span class="kw">for </span>(I, ErrorKind) {
<a href=#186 id=186 data-nosnippet>186</a> <span class="kw">fn </span>from_external_error(input: I, kind: ErrorKind, _e: E) -&gt; <span class="self">Self </span>{
<a href=#187 id=187 data-nosnippet>187</a> (input, kind)
<a href=#188 id=188 data-nosnippet>188</a> }
<a href=#189 id=189 data-nosnippet>189</a>}
<a href=#190 id=190 data-nosnippet>190</a>
<a href=#191 id=191 data-nosnippet>191</a><span class="kw">impl</span>&lt;I&gt; ParseError&lt;I&gt; <span class="kw">for </span>() {
<a href=#192 id=192 data-nosnippet>192</a> <span class="kw">fn </span>from_error_kind(<span class="kw">_</span>: I, <span class="kw">_</span>: ErrorKind) -&gt; <span class="self">Self </span>{}
<a href=#193 id=193 data-nosnippet>193</a>
<a href=#194 id=194 data-nosnippet>194</a> <span class="kw">fn </span>append(<span class="kw">_</span>: I, <span class="kw">_</span>: ErrorKind, <span class="kw">_</span>: <span class="self">Self</span>) -&gt; <span class="self">Self </span>{}
<a href=#195 id=195 data-nosnippet>195</a>}
<a href=#196 id=196 data-nosnippet>196</a>
<a href=#197 id=197 data-nosnippet>197</a><span class="kw">impl</span>&lt;I&gt; ContextError&lt;I&gt; <span class="kw">for </span>() {}
<a href=#198 id=198 data-nosnippet>198</a>
<a href=#199 id=199 data-nosnippet>199</a><span class="kw">impl</span>&lt;I, E&gt; FromExternalError&lt;I, E&gt; <span class="kw">for </span>() {
<a href=#200 id=200 data-nosnippet>200</a> <span class="kw">fn </span>from_external_error(_input: I, _kind: ErrorKind, _e: E) -&gt; <span class="self">Self </span>{}
<a href=#201 id=201 data-nosnippet>201</a>}
<a href=#202 id=202 data-nosnippet>202</a>
<a href=#203 id=203 data-nosnippet>203</a><span class="doccomment">/// Creates an error from the input position and an [ErrorKind]
<a href=#204 id=204 data-nosnippet>204</a></span><span class="kw">pub fn </span>make_error&lt;I, E: ParseError&lt;I&gt;&gt;(input: I, kind: ErrorKind) -&gt; E {
<a href=#205 id=205 data-nosnippet>205</a> E::from_error_kind(input, kind)
<a href=#206 id=206 data-nosnippet>206</a>}
<a href=#207 id=207 data-nosnippet>207</a>
<a href=#208 id=208 data-nosnippet>208</a><span class="doccomment">/// Combines an existing error with a new one created from the input
<a href=#209 id=209 data-nosnippet>209</a>/// position and an [ErrorKind]. This is useful when backtracking
<a href=#210 id=210 data-nosnippet>210</a>/// through a parse tree, accumulating error context on the way
<a href=#211 id=211 data-nosnippet>211</a></span><span class="kw">pub fn </span>append_error&lt;I, E: ParseError&lt;I&gt;&gt;(input: I, kind: ErrorKind, other: E) -&gt; E {
<a href=#212 id=212 data-nosnippet>212</a> E::append(input, kind, other)
<a href=#213 id=213 data-nosnippet>213</a>}
<a href=#214 id=214 data-nosnippet>214</a>
<a href=#215 id=215 data-nosnippet>215</a><span class="doccomment">/// Create a new error from an input position, a static string and an existing error.
<a href=#216 id=216 data-nosnippet>216</a>/// This is used mainly in the [context] combinator, to add user friendly information
<a href=#217 id=217 data-nosnippet>217</a>/// to errors when backtracking through a parse tree
<a href=#218 id=218 data-nosnippet>218</a></span><span class="kw">pub fn </span>context&lt;F&gt;(context: <span class="kw-2">&amp;</span><span class="lifetime">'static </span>str, parser: F) -&gt; Context&lt;F&gt; {
<a href=#219 id=219 data-nosnippet>219</a> Context { context, parser }
<a href=#220 id=220 data-nosnippet>220</a>}
<a href=#221 id=221 data-nosnippet>221</a>
<a href=#222 id=222 data-nosnippet>222</a><span class="doccomment">/// Parser implementation for [context]
<a href=#223 id=223 data-nosnippet>223</a></span><span class="kw">pub struct </span>Context&lt;F&gt; {
<a href=#224 id=224 data-nosnippet>224</a> context: <span class="kw-2">&amp;</span><span class="lifetime">'static </span>str,
<a href=#225 id=225 data-nosnippet>225</a> parser: F,
<a href=#226 id=226 data-nosnippet>226</a>}
<a href=#227 id=227 data-nosnippet>227</a>
<a href=#228 id=228 data-nosnippet>228</a><span class="kw">impl</span>&lt;I, F&gt; Parser&lt;I&gt; <span class="kw">for </span>Context&lt;F&gt;
<a href=#229 id=229 data-nosnippet>229</a><span class="kw">where
<a href=#230 id=230 data-nosnippet>230</a> </span>I: Clone,
<a href=#231 id=231 data-nosnippet>231</a> F: Parser&lt;I&gt;,
<a href=#232 id=232 data-nosnippet>232</a> &lt;F <span class="kw">as </span>Parser&lt;I&gt;&gt;::Error: ContextError&lt;I&gt;,
<a href=#233 id=233 data-nosnippet>233</a>{
<a href=#234 id=234 data-nosnippet>234</a> <span class="kw">type </span>Output = &lt;F <span class="kw">as </span>Parser&lt;I&gt;&gt;::Output;
<a href=#235 id=235 data-nosnippet>235</a> <span class="kw">type </span>Error = &lt;F <span class="kw">as </span>Parser&lt;I&gt;&gt;::Error;
<a href=#236 id=236 data-nosnippet>236</a>
<a href=#237 id=237 data-nosnippet>237</a> <span class="kw">fn </span>process&lt;OM: OutputMode&gt;(<span class="kw-2">&amp;mut </span><span class="self">self</span>, input: I) -&gt; PResult&lt;OM, I, <span class="self">Self</span>::Output, <span class="self">Self</span>::Error&gt; {
<a href=#238 id=238 data-nosnippet>238</a> <span class="kw">match </span><span class="self">self</span>.parser.process::&lt;OM&gt;(input.clone()) {
<a href=#239 id=239 data-nosnippet>239</a> <span class="prelude-val">Err</span>(Err::Error(e)) =&gt; <span class="prelude-val">Err</span>(Err::Error(OM::Error::map(e, |e| {
<a href=#240 id=240 data-nosnippet>240</a> &lt;F <span class="kw">as </span>Parser&lt;I&gt;&gt;::Error::add_context(input, <span class="self">self</span>.context, e)
<a href=#241 id=241 data-nosnippet>241</a> }))),
<a href=#242 id=242 data-nosnippet>242</a> <span class="prelude-val">Err</span>(Err::Failure(e)) =&gt; <span class="prelude-val">Err</span>(Err::Failure(&lt;F <span class="kw">as </span>Parser&lt;I&gt;&gt;::Error::add_context(
<a href=#243 id=243 data-nosnippet>243</a> input,
<a href=#244 id=244 data-nosnippet>244</a> <span class="self">self</span>.context,
<a href=#245 id=245 data-nosnippet>245</a> e,
<a href=#246 id=246 data-nosnippet>246</a> ))),
<a href=#247 id=247 data-nosnippet>247</a> x =&gt; x,
<a href=#248 id=248 data-nosnippet>248</a> }
<a href=#249 id=249 data-nosnippet>249</a> }
<a href=#250 id=250 data-nosnippet>250</a>}
<a href=#251 id=251 data-nosnippet>251</a>
<a href=#252 id=252 data-nosnippet>252</a><span class="doccomment">/// Indicates which parser returned an error
<a href=#253 id=253 data-nosnippet>253</a></span><span class="attr">#[rustfmt::skip]
<a href=#254 id=254 data-nosnippet>254</a>#[derive(Debug,PartialEq,Eq,Hash,Clone,Copy)]
<a href=#255 id=255 data-nosnippet>255</a>#[allow(deprecated,missing_docs)]
<a href=#256 id=256 data-nosnippet>256</a></span><span class="kw">pub enum </span>ErrorKind {
<a href=#257 id=257 data-nosnippet>257</a> Tag,
<a href=#258 id=258 data-nosnippet>258</a> MapRes,
<a href=#259 id=259 data-nosnippet>259</a> MapOpt,
<a href=#260 id=260 data-nosnippet>260</a> Alt,
<a href=#261 id=261 data-nosnippet>261</a> IsNot,
<a href=#262 id=262 data-nosnippet>262</a> IsA,
<a href=#263 id=263 data-nosnippet>263</a> SeparatedList,
<a href=#264 id=264 data-nosnippet>264</a> SeparatedNonEmptyList,
<a href=#265 id=265 data-nosnippet>265</a> Many0,
<a href=#266 id=266 data-nosnippet>266</a> Many1,
<a href=#267 id=267 data-nosnippet>267</a> ManyTill,
<a href=#268 id=268 data-nosnippet>268</a> Count,
<a href=#269 id=269 data-nosnippet>269</a> TakeUntil,
<a href=#270 id=270 data-nosnippet>270</a> LengthValue,
<a href=#271 id=271 data-nosnippet>271</a> TagClosure,
<a href=#272 id=272 data-nosnippet>272</a> Alpha,
<a href=#273 id=273 data-nosnippet>273</a> Digit,
<a href=#274 id=274 data-nosnippet>274</a> HexDigit,
<a href=#275 id=275 data-nosnippet>275</a> OctDigit,
<a href=#276 id=276 data-nosnippet>276</a> BinDigit,
<a href=#277 id=277 data-nosnippet>277</a> AlphaNumeric,
<a href=#278 id=278 data-nosnippet>278</a> Space,
<a href=#279 id=279 data-nosnippet>279</a> MultiSpace,
<a href=#280 id=280 data-nosnippet>280</a> LengthValueFn,
<a href=#281 id=281 data-nosnippet>281</a> Eof,
<a href=#282 id=282 data-nosnippet>282</a> Switch,
<a href=#283 id=283 data-nosnippet>283</a> TagBits,
<a href=#284 id=284 data-nosnippet>284</a> OneOf,
<a href=#285 id=285 data-nosnippet>285</a> NoneOf,
<a href=#286 id=286 data-nosnippet>286</a> Char,
<a href=#287 id=287 data-nosnippet>287</a> CrLf,
<a href=#288 id=288 data-nosnippet>288</a> RegexpMatch,
<a href=#289 id=289 data-nosnippet>289</a> RegexpMatches,
<a href=#290 id=290 data-nosnippet>290</a> RegexpFind,
<a href=#291 id=291 data-nosnippet>291</a> RegexpCapture,
<a href=#292 id=292 data-nosnippet>292</a> RegexpCaptures,
<a href=#293 id=293 data-nosnippet>293</a> TakeWhile1,
<a href=#294 id=294 data-nosnippet>294</a> Complete,
<a href=#295 id=295 data-nosnippet>295</a> Fix,
<a href=#296 id=296 data-nosnippet>296</a> Escaped,
<a href=#297 id=297 data-nosnippet>297</a> EscapedTransform,
<a href=#298 id=298 data-nosnippet>298</a> NonEmpty,
<a href=#299 id=299 data-nosnippet>299</a> ManyMN,
<a href=#300 id=300 data-nosnippet>300</a> Not,
<a href=#301 id=301 data-nosnippet>301</a> Permutation,
<a href=#302 id=302 data-nosnippet>302</a> Verify,
<a href=#303 id=303 data-nosnippet>303</a> TakeTill1,
<a href=#304 id=304 data-nosnippet>304</a> TakeWhileMN,
<a href=#305 id=305 data-nosnippet>305</a> TooLarge,
<a href=#306 id=306 data-nosnippet>306</a> Many0Count,
<a href=#307 id=307 data-nosnippet>307</a> Many1Count,
<a href=#308 id=308 data-nosnippet>308</a> Float,
<a href=#309 id=309 data-nosnippet>309</a> Satisfy,
<a href=#310 id=310 data-nosnippet>310</a> Fail,
<a href=#311 id=311 data-nosnippet>311</a> Many,
<a href=#312 id=312 data-nosnippet>312</a> Fold,
<a href=#313 id=313 data-nosnippet>313</a> Precedence,
<a href=#314 id=314 data-nosnippet>314</a>}
<a href=#315 id=315 data-nosnippet>315</a>
<a href=#316 id=316 data-nosnippet>316</a><span class="attr">#[rustfmt::skip]
<a href=#317 id=317 data-nosnippet>317</a>#[allow(deprecated)]
<a href=#318 id=318 data-nosnippet>318</a></span><span class="doccomment">/// Converts an ErrorKind to a number
<a href=#319 id=319 data-nosnippet>319</a></span><span class="kw">pub fn </span>error_to_u32(e: <span class="kw-2">&amp;</span>ErrorKind) -&gt; u32 {
<a href=#320 id=320 data-nosnippet>320</a> <span class="kw">match </span><span class="kw-2">*</span>e {
<a href=#321 id=321 data-nosnippet>321</a> ErrorKind::Tag =&gt; <span class="number">1</span>,
<a href=#322 id=322 data-nosnippet>322</a> ErrorKind::MapRes =&gt; <span class="number">2</span>,
<a href=#323 id=323 data-nosnippet>323</a> ErrorKind::MapOpt =&gt; <span class="number">3</span>,
<a href=#324 id=324 data-nosnippet>324</a> ErrorKind::Alt =&gt; <span class="number">4</span>,
<a href=#325 id=325 data-nosnippet>325</a> ErrorKind::IsNot =&gt; <span class="number">5</span>,
<a href=#326 id=326 data-nosnippet>326</a> ErrorKind::IsA =&gt; <span class="number">6</span>,
<a href=#327 id=327 data-nosnippet>327</a> ErrorKind::SeparatedList =&gt; <span class="number">7</span>,
<a href=#328 id=328 data-nosnippet>328</a> ErrorKind::SeparatedNonEmptyList =&gt; <span class="number">8</span>,
<a href=#329 id=329 data-nosnippet>329</a> ErrorKind::Many1 =&gt; <span class="number">9</span>,
<a href=#330 id=330 data-nosnippet>330</a> ErrorKind::Count =&gt; <span class="number">10</span>,
<a href=#331 id=331 data-nosnippet>331</a> ErrorKind::TakeUntil =&gt; <span class="number">12</span>,
<a href=#332 id=332 data-nosnippet>332</a> ErrorKind::LengthValue =&gt; <span class="number">15</span>,
<a href=#333 id=333 data-nosnippet>333</a> ErrorKind::TagClosure =&gt; <span class="number">16</span>,
<a href=#334 id=334 data-nosnippet>334</a> ErrorKind::Alpha =&gt; <span class="number">17</span>,
<a href=#335 id=335 data-nosnippet>335</a> ErrorKind::Digit =&gt; <span class="number">18</span>,
<a href=#336 id=336 data-nosnippet>336</a> ErrorKind::AlphaNumeric =&gt; <span class="number">19</span>,
<a href=#337 id=337 data-nosnippet>337</a> ErrorKind::Space =&gt; <span class="number">20</span>,
<a href=#338 id=338 data-nosnippet>338</a> ErrorKind::MultiSpace =&gt; <span class="number">21</span>,
<a href=#339 id=339 data-nosnippet>339</a> ErrorKind::LengthValueFn =&gt; <span class="number">22</span>,
<a href=#340 id=340 data-nosnippet>340</a> ErrorKind::Eof =&gt; <span class="number">23</span>,
<a href=#341 id=341 data-nosnippet>341</a> ErrorKind::Switch =&gt; <span class="number">27</span>,
<a href=#342 id=342 data-nosnippet>342</a> ErrorKind::TagBits =&gt; <span class="number">28</span>,
<a href=#343 id=343 data-nosnippet>343</a> ErrorKind::OneOf =&gt; <span class="number">29</span>,
<a href=#344 id=344 data-nosnippet>344</a> ErrorKind::NoneOf =&gt; <span class="number">30</span>,
<a href=#345 id=345 data-nosnippet>345</a> ErrorKind::Char =&gt; <span class="number">40</span>,
<a href=#346 id=346 data-nosnippet>346</a> ErrorKind::CrLf =&gt; <span class="number">41</span>,
<a href=#347 id=347 data-nosnippet>347</a> ErrorKind::RegexpMatch =&gt; <span class="number">42</span>,
<a href=#348 id=348 data-nosnippet>348</a> ErrorKind::RegexpMatches =&gt; <span class="number">43</span>,
<a href=#349 id=349 data-nosnippet>349</a> ErrorKind::RegexpFind =&gt; <span class="number">44</span>,
<a href=#350 id=350 data-nosnippet>350</a> ErrorKind::RegexpCapture =&gt; <span class="number">45</span>,
<a href=#351 id=351 data-nosnippet>351</a> ErrorKind::RegexpCaptures =&gt; <span class="number">46</span>,
<a href=#352 id=352 data-nosnippet>352</a> ErrorKind::TakeWhile1 =&gt; <span class="number">47</span>,
<a href=#353 id=353 data-nosnippet>353</a> ErrorKind::Complete =&gt; <span class="number">48</span>,
<a href=#354 id=354 data-nosnippet>354</a> ErrorKind::Fix =&gt; <span class="number">49</span>,
<a href=#355 id=355 data-nosnippet>355</a> ErrorKind::Escaped =&gt; <span class="number">50</span>,
<a href=#356 id=356 data-nosnippet>356</a> ErrorKind::EscapedTransform =&gt; <span class="number">51</span>,
<a href=#357 id=357 data-nosnippet>357</a> ErrorKind::NonEmpty =&gt; <span class="number">56</span>,
<a href=#358 id=358 data-nosnippet>358</a> ErrorKind::ManyMN =&gt; <span class="number">57</span>,
<a href=#359 id=359 data-nosnippet>359</a> ErrorKind::HexDigit =&gt; <span class="number">59</span>,
<a href=#360 id=360 data-nosnippet>360</a> ErrorKind::OctDigit =&gt; <span class="number">61</span>,
<a href=#361 id=361 data-nosnippet>361</a> ErrorKind::Many0 =&gt; <span class="number">62</span>,
<a href=#362 id=362 data-nosnippet>362</a> ErrorKind::Not =&gt; <span class="number">63</span>,
<a href=#363 id=363 data-nosnippet>363</a> ErrorKind::Permutation =&gt; <span class="number">64</span>,
<a href=#364 id=364 data-nosnippet>364</a> ErrorKind::ManyTill =&gt; <span class="number">65</span>,
<a href=#365 id=365 data-nosnippet>365</a> ErrorKind::Verify =&gt; <span class="number">66</span>,
<a href=#366 id=366 data-nosnippet>366</a> ErrorKind::TakeTill1 =&gt; <span class="number">67</span>,
<a href=#367 id=367 data-nosnippet>367</a> ErrorKind::TakeWhileMN =&gt; <span class="number">69</span>,
<a href=#368 id=368 data-nosnippet>368</a> ErrorKind::TooLarge =&gt; <span class="number">70</span>,
<a href=#369 id=369 data-nosnippet>369</a> ErrorKind::Many0Count =&gt; <span class="number">71</span>,
<a href=#370 id=370 data-nosnippet>370</a> ErrorKind::Many1Count =&gt; <span class="number">72</span>,
<a href=#371 id=371 data-nosnippet>371</a> ErrorKind::Float =&gt; <span class="number">73</span>,
<a href=#372 id=372 data-nosnippet>372</a> ErrorKind::Satisfy =&gt; <span class="number">74</span>,
<a href=#373 id=373 data-nosnippet>373</a> ErrorKind::Fail =&gt; <span class="number">75</span>,
<a href=#374 id=374 data-nosnippet>374</a> ErrorKind::Many =&gt; <span class="number">76</span>,
<a href=#375 id=375 data-nosnippet>375</a> ErrorKind::Fold =&gt; <span class="number">77</span>,
<a href=#376 id=376 data-nosnippet>376</a> ErrorKind::BinDigit =&gt; <span class="number">78</span>,
<a href=#377 id=377 data-nosnippet>377</a> ErrorKind::Precedence =&gt; <span class="number">79</span>,
<a href=#378 id=378 data-nosnippet>378</a> }
<a href=#379 id=379 data-nosnippet>379</a>}
<a href=#380 id=380 data-nosnippet>380</a>
<a href=#381 id=381 data-nosnippet>381</a><span class="kw">impl </span>ErrorKind {
<a href=#382 id=382 data-nosnippet>382</a> <span class="attr">#[rustfmt::skip]
<a href=#383 id=383 data-nosnippet>383</a> #[allow(deprecated)]
<a href=#384 id=384 data-nosnippet>384</a> </span><span class="doccomment">/// Converts an ErrorKind to a text description
<a href=#385 id=385 data-nosnippet>385</a> </span><span class="kw">pub fn </span>description(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; <span class="kw-2">&amp;</span>str {
<a href=#386 id=386 data-nosnippet>386</a> <span class="kw">match </span><span class="kw-2">*</span><span class="self">self </span>{
<a href=#387 id=387 data-nosnippet>387</a> ErrorKind::Tag =&gt; <span class="string">"Tag"</span>,
<a href=#388 id=388 data-nosnippet>388</a> ErrorKind::MapRes =&gt; <span class="string">"Map on Result"</span>,
<a href=#389 id=389 data-nosnippet>389</a> ErrorKind::MapOpt =&gt; <span class="string">"Map on Option"</span>,
<a href=#390 id=390 data-nosnippet>390</a> ErrorKind::Alt =&gt; <span class="string">"Alternative"</span>,
<a href=#391 id=391 data-nosnippet>391</a> ErrorKind::IsNot =&gt; <span class="string">"IsNot"</span>,
<a href=#392 id=392 data-nosnippet>392</a> ErrorKind::IsA =&gt; <span class="string">"IsA"</span>,
<a href=#393 id=393 data-nosnippet>393</a> ErrorKind::SeparatedList =&gt; <span class="string">"Separated list"</span>,
<a href=#394 id=394 data-nosnippet>394</a> ErrorKind::SeparatedNonEmptyList =&gt; <span class="string">"Separated non empty list"</span>,
<a href=#395 id=395 data-nosnippet>395</a> ErrorKind::Many0 =&gt; <span class="string">"Many0"</span>,
<a href=#396 id=396 data-nosnippet>396</a> ErrorKind::Many1 =&gt; <span class="string">"Many1"</span>,
<a href=#397 id=397 data-nosnippet>397</a> ErrorKind::Count =&gt; <span class="string">"Count"</span>,
<a href=#398 id=398 data-nosnippet>398</a> ErrorKind::TakeUntil =&gt; <span class="string">"Take until"</span>,
<a href=#399 id=399 data-nosnippet>399</a> ErrorKind::LengthValue =&gt; <span class="string">"Length followed by value"</span>,
<a href=#400 id=400 data-nosnippet>400</a> ErrorKind::TagClosure =&gt; <span class="string">"Tag closure"</span>,
<a href=#401 id=401 data-nosnippet>401</a> ErrorKind::Alpha =&gt; <span class="string">"Alphabetic"</span>,
<a href=#402 id=402 data-nosnippet>402</a> ErrorKind::Digit =&gt; <span class="string">"Digit"</span>,
<a href=#403 id=403 data-nosnippet>403</a> ErrorKind::AlphaNumeric =&gt; <span class="string">"AlphaNumeric"</span>,
<a href=#404 id=404 data-nosnippet>404</a> ErrorKind::Space =&gt; <span class="string">"Space"</span>,
<a href=#405 id=405 data-nosnippet>405</a> ErrorKind::MultiSpace =&gt; <span class="string">"Multiple spaces"</span>,
<a href=#406 id=406 data-nosnippet>406</a> ErrorKind::LengthValueFn =&gt; <span class="string">"LengthValueFn"</span>,
<a href=#407 id=407 data-nosnippet>407</a> ErrorKind::Eof =&gt; <span class="string">"End of file"</span>,
<a href=#408 id=408 data-nosnippet>408</a> ErrorKind::Switch =&gt; <span class="string">"Switch"</span>,
<a href=#409 id=409 data-nosnippet>409</a> ErrorKind::TagBits =&gt; <span class="string">"Tag on bitstream"</span>,
<a href=#410 id=410 data-nosnippet>410</a> ErrorKind::OneOf =&gt; <span class="string">"OneOf"</span>,
<a href=#411 id=411 data-nosnippet>411</a> ErrorKind::NoneOf =&gt; <span class="string">"NoneOf"</span>,
<a href=#412 id=412 data-nosnippet>412</a> ErrorKind::Char =&gt; <span class="string">"Char"</span>,
<a href=#413 id=413 data-nosnippet>413</a> ErrorKind::CrLf =&gt; <span class="string">"CrLf"</span>,
<a href=#414 id=414 data-nosnippet>414</a> ErrorKind::RegexpMatch =&gt; <span class="string">"RegexpMatch"</span>,
<a href=#415 id=415 data-nosnippet>415</a> ErrorKind::RegexpMatches =&gt; <span class="string">"RegexpMatches"</span>,
<a href=#416 id=416 data-nosnippet>416</a> ErrorKind::RegexpFind =&gt; <span class="string">"RegexpFind"</span>,
<a href=#417 id=417 data-nosnippet>417</a> ErrorKind::RegexpCapture =&gt; <span class="string">"RegexpCapture"</span>,
<a href=#418 id=418 data-nosnippet>418</a> ErrorKind::RegexpCaptures =&gt; <span class="string">"RegexpCaptures"</span>,
<a href=#419 id=419 data-nosnippet>419</a> ErrorKind::TakeWhile1 =&gt; <span class="string">"TakeWhile1"</span>,
<a href=#420 id=420 data-nosnippet>420</a> ErrorKind::Complete =&gt; <span class="string">"Complete"</span>,
<a href=#421 id=421 data-nosnippet>421</a> ErrorKind::Fix =&gt; <span class="string">"Fix"</span>,
<a href=#422 id=422 data-nosnippet>422</a> ErrorKind::Escaped =&gt; <span class="string">"Escaped"</span>,
<a href=#423 id=423 data-nosnippet>423</a> ErrorKind::EscapedTransform =&gt; <span class="string">"EscapedTransform"</span>,
<a href=#424 id=424 data-nosnippet>424</a> ErrorKind::NonEmpty =&gt; <span class="string">"NonEmpty"</span>,
<a href=#425 id=425 data-nosnippet>425</a> ErrorKind::ManyMN =&gt; <span class="string">"Many(m, n)"</span>,
<a href=#426 id=426 data-nosnippet>426</a> ErrorKind::HexDigit =&gt; <span class="string">"Hexadecimal Digit"</span>,
<a href=#427 id=427 data-nosnippet>427</a> ErrorKind::OctDigit =&gt; <span class="string">"Octal digit"</span>,
<a href=#428 id=428 data-nosnippet>428</a> ErrorKind::BinDigit =&gt; <span class="string">"Binary digit"</span>,
<a href=#429 id=429 data-nosnippet>429</a> ErrorKind::Not =&gt; <span class="string">"Negation"</span>,
<a href=#430 id=430 data-nosnippet>430</a> ErrorKind::Permutation =&gt; <span class="string">"Permutation"</span>,
<a href=#431 id=431 data-nosnippet>431</a> ErrorKind::ManyTill =&gt; <span class="string">"ManyTill"</span>,
<a href=#432 id=432 data-nosnippet>432</a> ErrorKind::Verify =&gt; <span class="string">"predicate verification"</span>,
<a href=#433 id=433 data-nosnippet>433</a> ErrorKind::TakeTill1 =&gt; <span class="string">"TakeTill1"</span>,
<a href=#434 id=434 data-nosnippet>434</a> ErrorKind::TakeWhileMN =&gt; <span class="string">"TakeWhileMN"</span>,
<a href=#435 id=435 data-nosnippet>435</a> ErrorKind::TooLarge =&gt; <span class="string">"Needed data size is too large"</span>,
<a href=#436 id=436 data-nosnippet>436</a> ErrorKind::Many0Count =&gt; <span class="string">"Count occurrence of &gt;=0 patterns"</span>,
<a href=#437 id=437 data-nosnippet>437</a> ErrorKind::Many1Count =&gt; <span class="string">"Count occurrence of &gt;=1 patterns"</span>,
<a href=#438 id=438 data-nosnippet>438</a> ErrorKind::Float =&gt; <span class="string">"Float"</span>,
<a href=#439 id=439 data-nosnippet>439</a> ErrorKind::Satisfy =&gt; <span class="string">"Satisfy"</span>,
<a href=#440 id=440 data-nosnippet>440</a> ErrorKind::Fail =&gt; <span class="string">"Fail"</span>,
<a href=#441 id=441 data-nosnippet>441</a> ErrorKind::Many =&gt; <span class="string">"Many"</span>,
<a href=#442 id=442 data-nosnippet>442</a> ErrorKind::Fold =&gt; <span class="string">"Fold"</span>,
<a href=#443 id=443 data-nosnippet>443</a> ErrorKind::Precedence =&gt; <span class="string">"Precedence"</span>,
<a href=#444 id=444 data-nosnippet>444</a> }
<a href=#445 id=445 data-nosnippet>445</a> }
<a href=#446 id=446 data-nosnippet>446</a>}
<a href=#447 id=447 data-nosnippet>447</a>
<a href=#448 id=448 data-nosnippet>448</a><span class="doccomment">/// Creates a parse error from a `nom::ErrorKind`
<a href=#449 id=449 data-nosnippet>449</a>/// and the position in the input
<a href=#450 id=450 data-nosnippet>450</a></span><span class="attr">#[allow(unused_variables)]
<a href=#451 id=451 data-nosnippet>451</a>#[macro_export(local_inner_macros)]
<a href=#452 id=452 data-nosnippet>452</a></span><span class="macro">macro_rules!</span> error_position(
<a href=#453 id=453 data-nosnippet>453</a> (<span class="macro-nonterminal">$input</span>:expr, <span class="macro-nonterminal">$code</span>:expr $(,)<span class="question-mark">?</span>) =&gt; ({
<a href=#454 id=454 data-nosnippet>454</a> <span class="macro-nonterminal">$crate::error::make_error</span>(<span class="macro-nonterminal">$input</span>, <span class="macro-nonterminal">$code</span>)
<a href=#455 id=455 data-nosnippet>455</a> });
<a href=#456 id=456 data-nosnippet>456</a>);
<a href=#457 id=457 data-nosnippet>457</a>
<a href=#458 id=458 data-nosnippet>458</a><span class="doccomment">/// Creates a parse error from a `nom::ErrorKind`,
<a href=#459 id=459 data-nosnippet>459</a>/// the position in the input and the next error in
<a href=#460 id=460 data-nosnippet>460</a>/// the parsing tree
<a href=#461 id=461 data-nosnippet>461</a></span><span class="attr">#[allow(unused_variables)]
<a href=#462 id=462 data-nosnippet>462</a>#[macro_export(local_inner_macros)]
<a href=#463 id=463 data-nosnippet>463</a></span><span class="macro">macro_rules!</span> error_node_position(
<a href=#464 id=464 data-nosnippet>464</a> (<span class="macro-nonterminal">$input</span>:expr, <span class="macro-nonterminal">$code</span>:expr, <span class="macro-nonterminal">$next</span>:expr $(,)<span class="question-mark">?</span>) =&gt; ({
<a href=#465 id=465 data-nosnippet>465</a> <span class="macro-nonterminal">$crate::error::append_error</span>(<span class="macro-nonterminal">$input</span>, <span class="macro-nonterminal">$code</span>, <span class="macro-nonterminal">$next</span>)
<a href=#466 id=466 data-nosnippet>466</a> });
<a href=#467 id=467 data-nosnippet>467</a>);
<a href=#468 id=468 data-nosnippet>468</a>
<a href=#469 id=469 data-nosnippet>469</a><span class="doccomment">/// Prints a message and the input if the parser fails.
<a href=#470 id=470 data-nosnippet>470</a>///
<a href=#471 id=471 data-nosnippet>471</a>/// The message prints the `Error` or `Incomplete`
<a href=#472 id=472 data-nosnippet>472</a>/// and the parser's calling code.
<a href=#473 id=473 data-nosnippet>473</a>///
<a href=#474 id=474 data-nosnippet>474</a>/// It also displays the input in hexdump format
<a href=#475 id=475 data-nosnippet>475</a>///
<a href=#476 id=476 data-nosnippet>476</a>/// ```rust
<a href=#477 id=477 data-nosnippet>477</a>/// use nom::{IResult, error::dbg_dmp, bytes::complete::tag};
<a href=#478 id=478 data-nosnippet>478</a>///
<a href=#479 id=479 data-nosnippet>479</a>/// fn f(i: &amp;[u8]) -&gt; IResult&lt;&amp;[u8], &amp;[u8]&gt; {
<a href=#480 id=480 data-nosnippet>480</a>/// dbg_dmp(tag("abcd"), "tag")(i)
<a href=#481 id=481 data-nosnippet>481</a>/// }
<a href=#482 id=482 data-nosnippet>482</a>///
<a href=#483 id=483 data-nosnippet>483</a>/// let a = &amp;b"efghijkl"[..];
<a href=#484 id=484 data-nosnippet>484</a>///
<a href=#485 id=485 data-nosnippet>485</a>/// // Will print the following message:
<a href=#486 id=486 data-nosnippet>486</a>/// // Error(Position(0, [101, 102, 103, 104, 105, 106, 107, 108])) at l.5 by ' tag ! ( "abcd" ) '
<a href=#487 id=487 data-nosnippet>487</a>/// // 00000000 65 66 67 68 69 6a 6b 6c efghijkl
<a href=#488 id=488 data-nosnippet>488</a>/// f(a);
<a href=#489 id=489 data-nosnippet>489</a>/// ```
<a href=#490 id=490 data-nosnippet>490</a></span><span class="attr">#[cfg(feature = <span class="string">"std"</span>)]
<a href=#491 id=491 data-nosnippet>491</a>#[cfg_attr(feature = <span class="string">"docsrs"</span>, doc(cfg(feature = <span class="string">"std"</span>)))]
<a href=#492 id=492 data-nosnippet>492</a></span><span class="kw">pub fn </span>dbg_dmp&lt;<span class="lifetime">'a</span>, F, O, E: std::fmt::Debug&gt;(
<a href=#493 id=493 data-nosnippet>493</a> f: F,
<a href=#494 id=494 data-nosnippet>494</a> context: <span class="kw-2">&amp;</span><span class="lifetime">'static </span>str,
<a href=#495 id=495 data-nosnippet>495</a>) -&gt; <span class="kw">impl </span>Fn(<span class="kw-2">&amp;</span><span class="lifetime">'a </span>[u8]) -&gt; IResult&lt;<span class="kw-2">&amp;</span><span class="lifetime">'a </span>[u8], O, E&gt;
<a href=#496 id=496 data-nosnippet>496</a><span class="kw">where
<a href=#497 id=497 data-nosnippet>497</a> </span>F: Fn(<span class="kw-2">&amp;</span><span class="lifetime">'a </span>[u8]) -&gt; IResult&lt;<span class="kw-2">&amp;</span><span class="lifetime">'a </span>[u8], O, E&gt;,
<a href=#498 id=498 data-nosnippet>498</a>{
<a href=#499 id=499 data-nosnippet>499</a> <span class="kw">use </span><span class="kw">crate</span>::HexDisplay;
<a href=#500 id=500 data-nosnippet>500</a> <span class="kw">move </span>|i: <span class="kw-2">&amp;</span><span class="lifetime">'a </span>[u8]| <span class="kw">match </span>f(i) {
<a href=#501 id=501 data-nosnippet>501</a> <span class="prelude-val">Err</span>(e) =&gt; {
<a href=#502 id=502 data-nosnippet>502</a> <span class="macro">println!</span>(<span class="string">"{}: Error({:?}) at:\n{}"</span>, context, e, i.to_hex(<span class="number">8</span>));
<a href=#503 id=503 data-nosnippet>503</a> <span class="prelude-val">Err</span>(e)
<a href=#504 id=504 data-nosnippet>504</a> }
<a href=#505 id=505 data-nosnippet>505</a> a =&gt; a,
<a href=#506 id=506 data-nosnippet>506</a> }
<a href=#507 id=507 data-nosnippet>507</a>}
<a href=#508 id=508 data-nosnippet>508</a>
<a href=#509 id=509 data-nosnippet>509</a><span class="attr">#[cfg(test)]
<a href=#510 id=510 data-nosnippet>510</a></span><span class="kw">mod </span>tests {
<a href=#511 id=511 data-nosnippet>511</a> <span class="kw">use super</span>::<span class="kw-2">*</span>;
<a href=#512 id=512 data-nosnippet>512</a>
<a href=#513 id=513 data-nosnippet>513</a> <span class="attr">#[test]
<a href=#514 id=514 data-nosnippet>514</a> </span><span class="kw">fn </span>context_test() {
<a href=#515 id=515 data-nosnippet>515</a> <span class="kw">use crate</span>::{character::char, combinator::cut, internal::Needed};
<a href=#516 id=516 data-nosnippet>516</a>
<a href=#517 id=517 data-nosnippet>517</a> <span class="attr">#[derive(Debug, PartialEq)]
<a href=#518 id=518 data-nosnippet>518</a> </span><span class="kw">struct </span>Error&lt;I&gt; {
<a href=#519 id=519 data-nosnippet>519</a> input: I,
<a href=#520 id=520 data-nosnippet>520</a> ctx: <span class="prelude-ty">Option</span>&lt;<span class="kw-2">&amp;</span><span class="lifetime">'static </span>str&gt;,
<a href=#521 id=521 data-nosnippet>521</a> }
<a href=#522 id=522 data-nosnippet>522</a>
<a href=#523 id=523 data-nosnippet>523</a> <span class="kw">impl</span>&lt;I&gt; ParseError&lt;I&gt; <span class="kw">for </span>Error&lt;I&gt; {
<a href=#524 id=524 data-nosnippet>524</a> <span class="kw">fn </span>from_error_kind(input: I, _kind: ErrorKind) -&gt; <span class="self">Self </span>{
<a href=#525 id=525 data-nosnippet>525</a> <span class="self">Self </span>{ input, ctx: <span class="prelude-val">None </span>}
<a href=#526 id=526 data-nosnippet>526</a> }
<a href=#527 id=527 data-nosnippet>527</a>
<a href=#528 id=528 data-nosnippet>528</a> <span class="kw">fn </span>append(input: I, _kind: ErrorKind, other: <span class="self">Self</span>) -&gt; <span class="self">Self </span>{
<a href=#529 id=529 data-nosnippet>529</a> <span class="self">Self </span>{
<a href=#530 id=530 data-nosnippet>530</a> input,
<a href=#531 id=531 data-nosnippet>531</a> ctx: other.ctx,
<a href=#532 id=532 data-nosnippet>532</a> }
<a href=#533 id=533 data-nosnippet>533</a> }
<a href=#534 id=534 data-nosnippet>534</a> }
<a href=#535 id=535 data-nosnippet>535</a>
<a href=#536 id=536 data-nosnippet>536</a> <span class="kw">impl</span>&lt;I&gt; ContextError&lt;I&gt; <span class="kw">for </span>Error&lt;I&gt; {
<a href=#537 id=537 data-nosnippet>537</a> <span class="kw">fn </span>add_context(input: I, ctx: <span class="kw-2">&amp;</span><span class="lifetime">'static </span>str, _other: <span class="self">Self</span>) -&gt; <span class="self">Self </span>{
<a href=#538 id=538 data-nosnippet>538</a> <span class="self">Self </span>{
<a href=#539 id=539 data-nosnippet>539</a> input,
<a href=#540 id=540 data-nosnippet>540</a> ctx: <span class="prelude-val">Some</span>(ctx),
<a href=#541 id=541 data-nosnippet>541</a> }
<a href=#542 id=542 data-nosnippet>542</a> }
<a href=#543 id=543 data-nosnippet>543</a> }
<a href=#544 id=544 data-nosnippet>544</a>
<a href=#545 id=545 data-nosnippet>545</a> <span class="macro">assert_eq!</span>(
<a href=#546 id=546 data-nosnippet>546</a> context(<span class="string">"ctx"</span>, char::&lt;<span class="kw">_</span>, Error&lt;<span class="kw">_</span>&gt;&gt;(<span class="string">'a'</span>)).parse(<span class="string">"abcd"</span>),
<a href=#547 id=547 data-nosnippet>547</a> <span class="prelude-val">Ok</span>((<span class="string">"bcd"</span>, <span class="string">'a'</span>))
<a href=#548 id=548 data-nosnippet>548</a> );
<a href=#549 id=549 data-nosnippet>549</a> <span class="macro">assert_eq!</span>(
<a href=#550 id=550 data-nosnippet>550</a> context(<span class="string">"ctx"</span>, char::&lt;<span class="kw">_</span>, Error&lt;<span class="kw">_</span>&gt;&gt;(<span class="string">'a'</span>)).parse(<span class="string">""</span>),
<a href=#551 id=551 data-nosnippet>551</a> <span class="prelude-val">Err</span>(Err::Incomplete(Needed::new(<span class="number">1</span>)))
<a href=#552 id=552 data-nosnippet>552</a> );
<a href=#553 id=553 data-nosnippet>553</a> <span class="macro">assert_eq!</span>(
<a href=#554 id=554 data-nosnippet>554</a> context(<span class="string">"ctx"</span>, char::&lt;<span class="kw">_</span>, Error&lt;<span class="kw">_</span>&gt;&gt;(<span class="string">'a'</span>)).parse_complete(<span class="string">""</span>),
<a href=#555 id=555 data-nosnippet>555</a> <span class="prelude-val">Err</span>(Err::Error(Error {
<a href=#556 id=556 data-nosnippet>556</a> input: <span class="string">""</span>,
<a href=#557 id=557 data-nosnippet>557</a> ctx: <span class="prelude-val">Some</span>(<span class="string">"ctx"</span>)
<a href=#558 id=558 data-nosnippet>558</a> }))
<a href=#559 id=559 data-nosnippet>559</a> );
<a href=#560 id=560 data-nosnippet>560</a> <span class="macro">assert_eq!</span>(
<a href=#561 id=561 data-nosnippet>561</a> context(<span class="string">"ctx"</span>, cut(char::&lt;<span class="kw">_</span>, Error&lt;<span class="kw">_</span>&gt;&gt;(<span class="string">'a'</span>))).parse(<span class="string">"bcd"</span>),
<a href=#562 id=562 data-nosnippet>562</a> <span class="prelude-val">Err</span>(Err::Failure(Error {
<a href=#563 id=563 data-nosnippet>563</a> input: <span class="string">"bcd"</span>,
<a href=#564 id=564 data-nosnippet>564</a> ctx: <span class="prelude-val">Some</span>(<span class="string">"ctx"</span>)
<a href=#565 id=565 data-nosnippet>565</a> }))
<a href=#566 id=566 data-nosnippet>566</a> );
<a href=#567 id=567 data-nosnippet>567</a> }
<a href=#568 id=568 data-nosnippet>568</a>
<a href=#569 id=569 data-nosnippet>569</a> <span class="attr">#[cfg(feature = <span class="string">"alloc"</span>)]
<a href=#570 id=570 data-nosnippet>570</a> #[test]
<a href=#571 id=571 data-nosnippet>571</a> </span><span class="kw">fn </span>clone_error() {
<a href=#572 id=572 data-nosnippet>572</a> <span class="kw">use </span><span class="kw">crate</span>::lib::std::string::String;
<a href=#573 id=573 data-nosnippet>573</a> <span class="kw">let </span>err = Error {
<a href=#574 id=574 data-nosnippet>574</a> code: ErrorKind::Eof,
<a href=#575 id=575 data-nosnippet>575</a> input: <span class="string">"test"</span>,
<a href=#576 id=576 data-nosnippet>576</a> };
<a href=#577 id=577 data-nosnippet>577</a>
<a href=#578 id=578 data-nosnippet>578</a> <span class="kw">let </span>_err: Error&lt;String&gt; = err.cloned();
<a href=#579 id=579 data-nosnippet>579</a> }
<a href=#580 id=580 data-nosnippet>580</a>
<a href=#581 id=581 data-nosnippet>581</a> <span class="attr">#[test]
<a href=#582 id=582 data-nosnippet>582</a> </span><span class="kw">fn </span>copy_error() {
<a href=#583 id=583 data-nosnippet>583</a> <span class="kw">let </span>err = Error {
<a href=#584 id=584 data-nosnippet>584</a> code: ErrorKind::Eof,
<a href=#585 id=585 data-nosnippet>585</a> input: <span class="kw-2">&amp;</span><span class="number">0_u8</span>,
<a href=#586 id=586 data-nosnippet>586</a> };
<a href=#587 id=587 data-nosnippet>587</a>
<a href=#588 id=588 data-nosnippet>588</a> <span class="kw">let </span>_err: Error&lt;u8&gt; = err.copied();
<a href=#589 id=589 data-nosnippet>589</a> }
<a href=#590 id=590 data-nosnippet>590</a>}
<a href=#591 id=591 data-nosnippet>591</a>
<a href=#592 id=592 data-nosnippet>592</a><span class="comment">/*
<a href=#593 id=593 data-nosnippet>593</a>#[cfg(feature = "alloc")]
<a href=#594 id=594 data-nosnippet>594</a>use lib::std::{vec::Vec, collections::HashMap};
<a href=#595 id=595 data-nosnippet>595</a>
<a href=#596 id=596 data-nosnippet>596</a>#[cfg(feature = "std")]
<a href=#597 id=597 data-nosnippet>597</a>use lib::std::hash::Hash;
<a href=#598 id=598 data-nosnippet>598</a>
<a href=#599 id=599 data-nosnippet>599</a>#[cfg(feature = "std")]
<a href=#600 id=600 data-nosnippet>600</a>pub fn add_error_pattern&lt;'a, I: Clone + Hash + Eq, O, E: Clone + Hash + Eq&gt;(
<a href=#601 id=601 data-nosnippet>601</a> h: &amp;mut HashMap&lt;VerboseError&lt;I&gt;, &amp;'a str&gt;,
<a href=#602 id=602 data-nosnippet>602</a> e: VerboseError&lt;I&gt;,
<a href=#603 id=603 data-nosnippet>603</a> message: &amp;'a str,
<a href=#604 id=604 data-nosnippet>604</a>) -&gt; bool {
<a href=#605 id=605 data-nosnippet>605</a> h.insert(e, message);
<a href=#606 id=606 data-nosnippet>606</a> true
<a href=#607 id=607 data-nosnippet>607</a>}
<a href=#608 id=608 data-nosnippet>608</a>
<a href=#609 id=609 data-nosnippet>609</a>pub fn slice_to_offsets(input: &amp;[u8], s: &amp;[u8]) -&gt; (usize, usize) {
<a href=#610 id=610 data-nosnippet>610</a> let start = input.as_ptr();
<a href=#611 id=611 data-nosnippet>611</a> let off1 = s.as_ptr() as usize - start as usize;
<a href=#612 id=612 data-nosnippet>612</a> let off2 = off1 + s.len();
<a href=#613 id=613 data-nosnippet>613</a> (off1, off2)
<a href=#614 id=614 data-nosnippet>614</a>}
<a href=#615 id=615 data-nosnippet>615</a>
<a href=#616 id=616 data-nosnippet>616</a>#[cfg(feature = "std")]
<a href=#617 id=617 data-nosnippet>617</a>pub fn prepare_errors&lt;O, E: Clone&gt;(input: &amp;[u8], e: VerboseError&lt;&amp;[u8]&gt;) -&gt; Option&lt;Vec&lt;(ErrorKind, usize, usize)&gt;&gt; {
<a href=#618 id=618 data-nosnippet>618</a> let mut v: Vec&lt;(ErrorKind, usize, usize)&gt; = Vec::new();
<a href=#619 id=619 data-nosnippet>619</a>
<a href=#620 id=620 data-nosnippet>620</a> for (p, kind) in e.errors.drain(..) {
<a href=#621 id=621 data-nosnippet>621</a> let (o1, o2) = slice_to_offsets(input, p);
<a href=#622 id=622 data-nosnippet>622</a> v.push((kind, o1, o2));
<a href=#623 id=623 data-nosnippet>623</a> }
<a href=#624 id=624 data-nosnippet>624</a>
<a href=#625 id=625 data-nosnippet>625</a> v.reverse();
<a href=#626 id=626 data-nosnippet>626</a> Some(v)
<a href=#627 id=627 data-nosnippet>627</a>}
<a href=#628 id=628 data-nosnippet>628</a>
<a href=#629 id=629 data-nosnippet>629</a>#[cfg(feature = "std")]
<a href=#630 id=630 data-nosnippet>630</a>pub fn print_error&lt;O, E: Clone&gt;(input: &amp;[u8], res: VerboseError&lt;&amp;[u8]&gt;) {
<a href=#631 id=631 data-nosnippet>631</a> if let Some(v) = prepare_errors(input, res) {
<a href=#632 id=632 data-nosnippet>632</a> let colors = generate_colors(&amp;v);
<a href=#633 id=633 data-nosnippet>633</a> println!("parser codes: {}", print_codes(&amp;colors, &amp;HashMap::new()));
<a href=#634 id=634 data-nosnippet>634</a> println!("{}", print_offsets(input, 0, &amp;v));
<a href=#635 id=635 data-nosnippet>635</a> } else {
<a href=#636 id=636 data-nosnippet>636</a> println!("not an error");
<a href=#637 id=637 data-nosnippet>637</a> }
<a href=#638 id=638 data-nosnippet>638</a>}
<a href=#639 id=639 data-nosnippet>639</a>
<a href=#640 id=640 data-nosnippet>640</a>#[cfg(feature = "std")]
<a href=#641 id=641 data-nosnippet>641</a>pub fn generate_colors&lt;E&gt;(v: &amp;[(ErrorKind, usize, usize)]) -&gt; HashMap&lt;u32, u8&gt; {
<a href=#642 id=642 data-nosnippet>642</a> let mut h: HashMap&lt;u32, u8&gt; = HashMap::new();
<a href=#643 id=643 data-nosnippet>643</a> let mut color = 0;
<a href=#644 id=644 data-nosnippet>644</a>
<a href=#645 id=645 data-nosnippet>645</a> for &amp;(ref c, _, _) in v.iter() {
<a href=#646 id=646 data-nosnippet>646</a> h.insert(error_to_u32(c), color + 31);
<a href=#647 id=647 data-nosnippet>647</a> color = color + 1 % 7;
<a href=#648 id=648 data-nosnippet>648</a> }
<a href=#649 id=649 data-nosnippet>649</a>
<a href=#650 id=650 data-nosnippet>650</a> h
<a href=#651 id=651 data-nosnippet>651</a>}
<a href=#652 id=652 data-nosnippet>652</a>
<a href=#653 id=653 data-nosnippet>653</a>pub fn code_from_offset(v: &amp;[(ErrorKind, usize, usize)], offset: usize) -&gt; Option&lt;u32&gt; {
<a href=#654 id=654 data-nosnippet>654</a> let mut acc: Option&lt;(u32, usize, usize)&gt; = None;
<a href=#655 id=655 data-nosnippet>655</a> for &amp;(ref ek, s, e) in v.iter() {
<a href=#656 id=656 data-nosnippet>656</a> let c = error_to_u32(ek);
<a href=#657 id=657 data-nosnippet>657</a> if s &lt;= offset &amp;&amp; offset &lt;= e {
<a href=#658 id=658 data-nosnippet>658</a> if let Some((_, start, end)) = acc {
<a href=#659 id=659 data-nosnippet>659</a> if start &lt;= s &amp;&amp; e &lt;= end {
<a href=#660 id=660 data-nosnippet>660</a> acc = Some((c, s, e));
<a href=#661 id=661 data-nosnippet>661</a> }
<a href=#662 id=662 data-nosnippet>662</a> } else {
<a href=#663 id=663 data-nosnippet>663</a> acc = Some((c, s, e));
<a href=#664 id=664 data-nosnippet>664</a> }
<a href=#665 id=665 data-nosnippet>665</a> }
<a href=#666 id=666 data-nosnippet>666</a> }
<a href=#667 id=667 data-nosnippet>667</a> if let Some((code, _, _)) = acc {
<a href=#668 id=668 data-nosnippet>668</a> return Some(code);
<a href=#669 id=669 data-nosnippet>669</a> } else {
<a href=#670 id=670 data-nosnippet>670</a> return None;
<a href=#671 id=671 data-nosnippet>671</a> }
<a href=#672 id=672 data-nosnippet>672</a>}
<a href=#673 id=673 data-nosnippet>673</a>
<a href=#674 id=674 data-nosnippet>674</a>#[cfg(feature = "alloc")]
<a href=#675 id=675 data-nosnippet>675</a>pub fn reset_color(v: &amp;mut Vec&lt;u8&gt;) {
<a href=#676 id=676 data-nosnippet>676</a> v.push(0x1B);
<a href=#677 id=677 data-nosnippet>677</a> v.push(b'[');
<a href=#678 id=678 data-nosnippet>678</a> v.push(0);
<a href=#679 id=679 data-nosnippet>679</a> v.push(b'm');
<a href=#680 id=680 data-nosnippet>680</a>}
<a href=#681 id=681 data-nosnippet>681</a>
<a href=#682 id=682 data-nosnippet>682</a>#[cfg(feature = "alloc")]
<a href=#683 id=683 data-nosnippet>683</a>pub fn write_color(v: &amp;mut Vec&lt;u8&gt;, color: u8) {
<a href=#684 id=684 data-nosnippet>684</a> v.push(0x1B);
<a href=#685 id=685 data-nosnippet>685</a> v.push(b'[');
<a href=#686 id=686 data-nosnippet>686</a> v.push(1);
<a href=#687 id=687 data-nosnippet>687</a> v.push(b';');
<a href=#688 id=688 data-nosnippet>688</a> let s = color.to_string();
<a href=#689 id=689 data-nosnippet>689</a> let bytes = s.as_bytes();
<a href=#690 id=690 data-nosnippet>690</a> v.extend(bytes.iter().cloned());
<a href=#691 id=691 data-nosnippet>691</a> v.push(b'm');
<a href=#692 id=692 data-nosnippet>692</a>}
<a href=#693 id=693 data-nosnippet>693</a>
<a href=#694 id=694 data-nosnippet>694</a>#[cfg(feature = "std")]
<a href=#695 id=695 data-nosnippet>695</a>#[cfg_attr(feature = "cargo-clippy", allow(implicit_hasher))]
<a href=#696 id=696 data-nosnippet>696</a>pub fn print_codes(colors: &amp;HashMap&lt;u32, u8&gt;, names: &amp;HashMap&lt;u32, &amp;str&gt;) -&gt; String {
<a href=#697 id=697 data-nosnippet>697</a> let mut v = Vec::new();
<a href=#698 id=698 data-nosnippet>698</a> for (code, &amp;color) in colors {
<a href=#699 id=699 data-nosnippet>699</a> if let Some(&amp;s) = names.get(code) {
<a href=#700 id=700 data-nosnippet>700</a> let bytes = s.as_bytes();
<a href=#701 id=701 data-nosnippet>701</a> write_color(&amp;mut v, color);
<a href=#702 id=702 data-nosnippet>702</a> v.extend(bytes.iter().cloned());
<a href=#703 id=703 data-nosnippet>703</a> } else {
<a href=#704 id=704 data-nosnippet>704</a> let s = code.to_string();
<a href=#705 id=705 data-nosnippet>705</a> let bytes = s.as_bytes();
<a href=#706 id=706 data-nosnippet>706</a> write_color(&amp;mut v, color);
<a href=#707 id=707 data-nosnippet>707</a> v.extend(bytes.iter().cloned());
<a href=#708 id=708 data-nosnippet>708</a> }
<a href=#709 id=709 data-nosnippet>709</a> reset_color(&amp;mut v);
<a href=#710 id=710 data-nosnippet>710</a> v.push(b' ');
<a href=#711 id=711 data-nosnippet>711</a> }
<a href=#712 id=712 data-nosnippet>712</a> reset_color(&amp;mut v);
<a href=#713 id=713 data-nosnippet>713</a>
<a href=#714 id=714 data-nosnippet>714</a> String::from_utf8_lossy(&amp;v[..]).into_owned()
<a href=#715 id=715 data-nosnippet>715</a>}
<a href=#716 id=716 data-nosnippet>716</a>
<a href=#717 id=717 data-nosnippet>717</a>#[cfg(feature = "std")]
<a href=#718 id=718 data-nosnippet>718</a>pub fn print_offsets(input: &amp;[u8], from: usize, offsets: &amp;[(ErrorKind, usize, usize)]) -&gt; String {
<a href=#719 id=719 data-nosnippet>719</a> let mut v = Vec::with_capacity(input.len() * 3);
<a href=#720 id=720 data-nosnippet>720</a> let mut i = from;
<a href=#721 id=721 data-nosnippet>721</a> let chunk_size = 8;
<a href=#722 id=722 data-nosnippet>722</a> let mut current_code: Option&lt;u32&gt; = None;
<a href=#723 id=723 data-nosnippet>723</a> let mut current_code2: Option&lt;u32&gt; = None;
<a href=#724 id=724 data-nosnippet>724</a>
<a href=#725 id=725 data-nosnippet>725</a> let colors = generate_colors(&amp;offsets);
<a href=#726 id=726 data-nosnippet>726</a>
<a href=#727 id=727 data-nosnippet>727</a> for chunk in input.chunks(chunk_size) {
<a href=#728 id=728 data-nosnippet>728</a> let s = format!("{:08x}", i);
<a href=#729 id=729 data-nosnippet>729</a> for &amp;ch in s.as_bytes().iter() {
<a href=#730 id=730 data-nosnippet>730</a> v.push(ch);
<a href=#731 id=731 data-nosnippet>731</a> }
<a href=#732 id=732 data-nosnippet>732</a> v.push(b'\t');
<a href=#733 id=733 data-nosnippet>733</a>
<a href=#734 id=734 data-nosnippet>734</a> let mut k = i;
<a href=#735 id=735 data-nosnippet>735</a> let mut l = i;
<a href=#736 id=736 data-nosnippet>736</a> for &amp;byte in chunk {
<a href=#737 id=737 data-nosnippet>737</a> if let Some(code) = code_from_offset(&amp;offsets, k) {
<a href=#738 id=738 data-nosnippet>738</a> if let Some(current) = current_code {
<a href=#739 id=739 data-nosnippet>739</a> if current != code {
<a href=#740 id=740 data-nosnippet>740</a> reset_color(&amp;mut v);
<a href=#741 id=741 data-nosnippet>741</a> current_code = Some(code);
<a href=#742 id=742 data-nosnippet>742</a> if let Some(&amp;color) = colors.get(&amp;code) {
<a href=#743 id=743 data-nosnippet>743</a> write_color(&amp;mut v, color);
<a href=#744 id=744 data-nosnippet>744</a> }
<a href=#745 id=745 data-nosnippet>745</a> }
<a href=#746 id=746 data-nosnippet>746</a> } else {
<a href=#747 id=747 data-nosnippet>747</a> current_code = Some(code);
<a href=#748 id=748 data-nosnippet>748</a> if let Some(&amp;color) = colors.get(&amp;code) {
<a href=#749 id=749 data-nosnippet>749</a> write_color(&amp;mut v, color);
<a href=#750 id=750 data-nosnippet>750</a> }
<a href=#751 id=751 data-nosnippet>751</a> }
<a href=#752 id=752 data-nosnippet>752</a> }
<a href=#753 id=753 data-nosnippet>753</a> v.push(CHARS[(byte &gt;&gt; 4) as usize]);
<a href=#754 id=754 data-nosnippet>754</a> v.push(CHARS[(byte &amp; 0xf) as usize]);
<a href=#755 id=755 data-nosnippet>755</a> v.push(b' ');
<a href=#756 id=756 data-nosnippet>756</a> k = k + 1;
<a href=#757 id=757 data-nosnippet>757</a> }
<a href=#758 id=758 data-nosnippet>758</a>
<a href=#759 id=759 data-nosnippet>759</a> reset_color(&amp;mut v);
<a href=#760 id=760 data-nosnippet>760</a>
<a href=#761 id=761 data-nosnippet>761</a> if chunk_size &gt; chunk.len() {
<a href=#762 id=762 data-nosnippet>762</a> for _ in 0..(chunk_size - chunk.len()) {
<a href=#763 id=763 data-nosnippet>763</a> v.push(b' ');
<a href=#764 id=764 data-nosnippet>764</a> v.push(b' ');
<a href=#765 id=765 data-nosnippet>765</a> v.push(b' ');
<a href=#766 id=766 data-nosnippet>766</a> }
<a href=#767 id=767 data-nosnippet>767</a> }
<a href=#768 id=768 data-nosnippet>768</a> v.push(b'\t');
<a href=#769 id=769 data-nosnippet>769</a>
<a href=#770 id=770 data-nosnippet>770</a> for &amp;byte in chunk {
<a href=#771 id=771 data-nosnippet>771</a> if let Some(code) = code_from_offset(&amp;offsets, l) {
<a href=#772 id=772 data-nosnippet>772</a> if let Some(current) = current_code2 {
<a href=#773 id=773 data-nosnippet>773</a> if current != code {
<a href=#774 id=774 data-nosnippet>774</a> reset_color(&amp;mut v);
<a href=#775 id=775 data-nosnippet>775</a> current_code2 = Some(code);
<a href=#776 id=776 data-nosnippet>776</a> if let Some(&amp;color) = colors.get(&amp;code) {
<a href=#777 id=777 data-nosnippet>777</a> write_color(&amp;mut v, color);
<a href=#778 id=778 data-nosnippet>778</a> }
<a href=#779 id=779 data-nosnippet>779</a> }
<a href=#780 id=780 data-nosnippet>780</a> } else {
<a href=#781 id=781 data-nosnippet>781</a> current_code2 = Some(code);
<a href=#782 id=782 data-nosnippet>782</a> if let Some(&amp;color) = colors.get(&amp;code) {
<a href=#783 id=783 data-nosnippet>783</a> write_color(&amp;mut v, color);
<a href=#784 id=784 data-nosnippet>784</a> }
<a href=#785 id=785 data-nosnippet>785</a> }
<a href=#786 id=786 data-nosnippet>786</a> }
<a href=#787 id=787 data-nosnippet>787</a> if (byte &gt;= 32 &amp;&amp; byte &lt;= 126) || byte &gt;= 128 {
<a href=#788 id=788 data-nosnippet>788</a> v.push(byte);
<a href=#789 id=789 data-nosnippet>789</a> } else {
<a href=#790 id=790 data-nosnippet>790</a> v.push(b'.');
<a href=#791 id=791 data-nosnippet>791</a> }
<a href=#792 id=792 data-nosnippet>792</a> l = l + 1;
<a href=#793 id=793 data-nosnippet>793</a> }
<a href=#794 id=794 data-nosnippet>794</a> reset_color(&amp;mut v);
<a href=#795 id=795 data-nosnippet>795</a>
<a href=#796 id=796 data-nosnippet>796</a> v.push(b'\n');
<a href=#797 id=797 data-nosnippet>797</a> i = i + chunk_size;
<a href=#798 id=798 data-nosnippet>798</a> }
<a href=#799 id=799 data-nosnippet>799</a>
<a href=#800 id=800 data-nosnippet>800</a> String::from_utf8_lossy(&amp;v[..]).into_owned()
<a href=#801 id=801 data-nosnippet>801</a>}
<a href=#802 id=802 data-nosnippet>802</a>*/
</span></code></pre></div></section></main></body></html>
+860
View File
@@ -0,0 +1,860 @@
<!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 of the Rust file `/home/newkirk/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/nom-8.0.0/src/internal.rs`."><title>internal.rs - source</title><script>if(window.location.protocol!=="file:")document.head.insertAdjacentHTML("beforeend","SourceSerif4-Regular-6b053e98.ttf.woff2,FiraSans-Italic-81dc35de.woff2,FiraSans-Regular-0fe48ade.woff2,FiraSans-MediumItalic-ccf7e434.woff2,FiraSans-Medium-e1aa3f0a.woff2,SourceCodePro-Regular-8badfe75.ttf.woff2,SourceCodePro-Semibold-aa29a496.ttf.woff2".split(",").map(f=>`<link rel="preload" as="font" type="font/woff2"href="../../static.files/${f}">`).join(""))</script><link rel="stylesheet" href="../../static.files/normalize-9960930a.css"><link rel="stylesheet" href="../../static.files/rustdoc-ca0dd0c4.css"><meta name="rustdoc-vars" data-root-path="../../" data-static-root-path="../../static.files/" data-current-crate="nom" data-themes="" data-resource-suffix="" data-rustdoc-version="1.93.1 (01f6ddf75 2026-02-11) (Arch Linux rust 1:1.93.1-1)" data-channel="1.93.1" data-search-js="search-9e2438ea.js" data-stringdex-js="stringdex-a3946164.js" data-settings-js="settings-c38705f0.js" ><script src="../../static.files/storage-e2aeef58.js"></script><script defer src="../../static.files/src-script-813739b1.js"></script><script defer src="../../src-files.js"></script><script defer src="../../static.files/main-a410ff4d.js"></script><noscript><link rel="stylesheet" href="../../static.files/noscript-263c88ec.css"></noscript><link rel="alternate icon" type="image/png" href="../../static.files/favicon-32x32-eab170b8.png"><link rel="icon" type="image/svg+xml" href="../../static.files/favicon-044be391.svg"></head><body class="rustdoc src"><!--[if lte IE 11]><div class="warning">This old browser is unsupported and will most likely display funky things.</div><![endif]--><nav class="sidebar"><div class="src-sidebar-title"><h2>Files</h2></div></nav><div class="sidebar-resizer" title="Drag to resize sidebar"></div><main><section id="main-content" class="content"><div class="main-heading"><h1><div class="sub-heading">nom/</div>internal.rs</h1><rustdoc-toolbar></rustdoc-toolbar></div><div class="example-wrap digits-3"><pre class="rust"><code><a href=#1 id=1 data-nosnippet>1</a><span class="doccomment">//! Basic types to build the parsers
<a href=#2 id=2 data-nosnippet>2</a>
<a href=#3 id=3 data-nosnippet>3</a></span><span class="kw">use </span><span class="self">self</span>::Needed::<span class="kw-2">*</span>;
<a href=#4 id=4 data-nosnippet>4</a><span class="kw">use </span><span class="kw">crate</span>::error::{<span class="self">self</span>, ErrorKind, FromExternalError, ParseError};
<a href=#5 id=5 data-nosnippet>5</a><span class="kw">use </span><span class="kw">crate</span>::lib::std::fmt;
<a href=#6 id=6 data-nosnippet>6</a><span class="kw">use </span>core::marker::PhantomData;
<a href=#7 id=7 data-nosnippet>7</a><span class="kw">use </span>core::num::NonZeroUsize;
<a href=#8 id=8 data-nosnippet>8</a>
<a href=#9 id=9 data-nosnippet>9</a><span class="doccomment">/// Holds the result of parsing functions
<a href=#10 id=10 data-nosnippet>10</a>///
<a href=#11 id=11 data-nosnippet>11</a>/// It depends on the input type `I`, the output type `O`, and the error type `E`
<a href=#12 id=12 data-nosnippet>12</a>/// (by default `(I, nom::ErrorKind)`)
<a href=#13 id=13 data-nosnippet>13</a>///
<a href=#14 id=14 data-nosnippet>14</a>/// The `Ok` side is a pair containing the remainder of the input (the part of the data that
<a href=#15 id=15 data-nosnippet>15</a>/// was not parsed) and the produced value. The `Err` side contains an instance of `nom::Err`.
<a href=#16 id=16 data-nosnippet>16</a>///
<a href=#17 id=17 data-nosnippet>17</a>/// Outside of the parsing code, you can use the [Finish::finish] method to convert
<a href=#18 id=18 data-nosnippet>18</a>/// it to a more common result type
<a href=#19 id=19 data-nosnippet>19</a></span><span class="kw">pub type </span>IResult&lt;I, O, E = error::Error&lt;I&gt;&gt; = <span class="prelude-ty">Result</span>&lt;(I, O), <span class="prelude-val">Err</span>&lt;E&gt;&gt;;
<a href=#20 id=20 data-nosnippet>20</a>
<a href=#21 id=21 data-nosnippet>21</a><span class="doccomment">/// Helper trait to convert a parser's result to a more manageable type
<a href=#22 id=22 data-nosnippet>22</a></span><span class="kw">pub trait </span>Finish&lt;I, O, E&gt; {
<a href=#23 id=23 data-nosnippet>23</a> <span class="doccomment">/// converts the parser's result to a type that is more consumable by error
<a href=#24 id=24 data-nosnippet>24</a> /// management libraries. It keeps the same `Ok` branch, and merges `Err::Error`
<a href=#25 id=25 data-nosnippet>25</a> /// and `Err::Failure` into the `Err` side.
<a href=#26 id=26 data-nosnippet>26</a> ///
<a href=#27 id=27 data-nosnippet>27</a> /// *warning*: if the result is `Err(Err::Incomplete(_))`, this method will panic.
<a href=#28 id=28 data-nosnippet>28</a> /// - "complete" parsers: It will not be an issue, `Incomplete` is never used
<a href=#29 id=29 data-nosnippet>29</a> /// - "streaming" parsers: `Incomplete` will be returned if there's not enough data
<a href=#30 id=30 data-nosnippet>30</a> /// for the parser to decide, and you should gather more data before parsing again.
<a href=#31 id=31 data-nosnippet>31</a> /// Once the parser returns either `Ok(_)`, `Err(Err::Error(_))` or `Err(Err::Failure(_))`,
<a href=#32 id=32 data-nosnippet>32</a> /// you can get out of the parsing loop and call `finish()` on the parser's result
<a href=#33 id=33 data-nosnippet>33</a> </span><span class="kw">fn </span>finish(<span class="self">self</span>) -&gt; <span class="prelude-ty">Result</span>&lt;(I, O), E&gt;;
<a href=#34 id=34 data-nosnippet>34</a>}
<a href=#35 id=35 data-nosnippet>35</a>
<a href=#36 id=36 data-nosnippet>36</a><span class="kw">impl</span>&lt;I, O, E&gt; Finish&lt;I, O, E&gt; <span class="kw">for </span>IResult&lt;I, O, E&gt; {
<a href=#37 id=37 data-nosnippet>37</a> <span class="kw">fn </span>finish(<span class="self">self</span>) -&gt; <span class="prelude-ty">Result</span>&lt;(I, O), E&gt; {
<a href=#38 id=38 data-nosnippet>38</a> <span class="kw">match </span><span class="self">self </span>{
<a href=#39 id=39 data-nosnippet>39</a> <span class="prelude-val">Ok</span>(res) =&gt; <span class="prelude-val">Ok</span>(res),
<a href=#40 id=40 data-nosnippet>40</a> <span class="prelude-val">Err</span>(Err::Error(e)) | <span class="prelude-val">Err</span>(Err::Failure(e)) =&gt; <span class="prelude-val">Err</span>(e),
<a href=#41 id=41 data-nosnippet>41</a> <span class="prelude-val">Err</span>(Err::Incomplete(<span class="kw">_</span>)) =&gt; {
<a href=#42 id=42 data-nosnippet>42</a> <span class="macro">panic!</span>(<span class="string">"Cannot call `finish()` on `Err(Err::Incomplete(_))`: this result means that the parser does not have enough data to decide, you should gather more data and try to reapply the parser instead"</span>)
<a href=#43 id=43 data-nosnippet>43</a> }
<a href=#44 id=44 data-nosnippet>44</a> }
<a href=#45 id=45 data-nosnippet>45</a> }
<a href=#46 id=46 data-nosnippet>46</a>}
<a href=#47 id=47 data-nosnippet>47</a>
<a href=#48 id=48 data-nosnippet>48</a><span class="doccomment">/// Contains information on needed data if a parser returned `Incomplete`
<a href=#49 id=49 data-nosnippet>49</a></span><span class="attr">#[derive(Debug, PartialEq, Eq, Clone, Copy)]
<a href=#50 id=50 data-nosnippet>50</a></span><span class="kw">pub enum </span>Needed {
<a href=#51 id=51 data-nosnippet>51</a> <span class="doccomment">/// Needs more data, but we do not know how much
<a href=#52 id=52 data-nosnippet>52</a> </span>Unknown,
<a href=#53 id=53 data-nosnippet>53</a> <span class="doccomment">/// Contains the required data size in bytes
<a href=#54 id=54 data-nosnippet>54</a> </span>Size(NonZeroUsize),
<a href=#55 id=55 data-nosnippet>55</a>}
<a href=#56 id=56 data-nosnippet>56</a>
<a href=#57 id=57 data-nosnippet>57</a><span class="kw">impl </span>Needed {
<a href=#58 id=58 data-nosnippet>58</a> <span class="doccomment">/// Creates `Needed` instance, returns `Needed::Unknown` if the argument is zero
<a href=#59 id=59 data-nosnippet>59</a> </span><span class="kw">pub fn </span>new(s: usize) -&gt; <span class="self">Self </span>{
<a href=#60 id=60 data-nosnippet>60</a> <span class="kw">match </span>NonZeroUsize::new(s) {
<a href=#61 id=61 data-nosnippet>61</a> <span class="prelude-val">Some</span>(sz) =&gt; Needed::Size(sz),
<a href=#62 id=62 data-nosnippet>62</a> <span class="prelude-val">None </span>=&gt; Needed::Unknown,
<a href=#63 id=63 data-nosnippet>63</a> }
<a href=#64 id=64 data-nosnippet>64</a> }
<a href=#65 id=65 data-nosnippet>65</a>
<a href=#66 id=66 data-nosnippet>66</a> <span class="doccomment">/// Indicates if we know how many bytes we need
<a href=#67 id=67 data-nosnippet>67</a> </span><span class="kw">pub fn </span>is_known(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; bool {
<a href=#68 id=68 data-nosnippet>68</a> <span class="kw-2">*</span><span class="self">self </span>!= Unknown
<a href=#69 id=69 data-nosnippet>69</a> }
<a href=#70 id=70 data-nosnippet>70</a>
<a href=#71 id=71 data-nosnippet>71</a> <span class="doccomment">/// Maps a `Needed` to `Needed` by applying a function to a contained `Size` value.
<a href=#72 id=72 data-nosnippet>72</a> </span><span class="attr">#[inline]
<a href=#73 id=73 data-nosnippet>73</a> </span><span class="kw">pub fn </span>map&lt;F: Fn(NonZeroUsize) -&gt; usize&gt;(<span class="self">self</span>, f: F) -&gt; Needed {
<a href=#74 id=74 data-nosnippet>74</a> <span class="kw">match </span><span class="self">self </span>{
<a href=#75 id=75 data-nosnippet>75</a> Unknown =&gt; Unknown,
<a href=#76 id=76 data-nosnippet>76</a> Size(n) =&gt; Needed::new(f(n)),
<a href=#77 id=77 data-nosnippet>77</a> }
<a href=#78 id=78 data-nosnippet>78</a> }
<a href=#79 id=79 data-nosnippet>79</a>}
<a href=#80 id=80 data-nosnippet>80</a>
<a href=#81 id=81 data-nosnippet>81</a><span class="doccomment">/// The `Err` enum indicates the parser was not successful
<a href=#82 id=82 data-nosnippet>82</a>///
<a href=#83 id=83 data-nosnippet>83</a>/// It has three cases:
<a href=#84 id=84 data-nosnippet>84</a>///
<a href=#85 id=85 data-nosnippet>85</a>/// * `Incomplete` indicates that more data is needed to decide. The `Needed` enum
<a href=#86 id=86 data-nosnippet>86</a>/// can contain how many additional bytes are necessary. If you are sure your parser
<a href=#87 id=87 data-nosnippet>87</a>/// is working on full data, you can wrap your parser with the `complete` combinator
<a href=#88 id=88 data-nosnippet>88</a>/// to transform that case in `Error`
<a href=#89 id=89 data-nosnippet>89</a>/// * `Error` means some parser did not succeed, but another one might (as an example,
<a href=#90 id=90 data-nosnippet>90</a>/// when testing different branches of an `alt` combinator)
<a href=#91 id=91 data-nosnippet>91</a>/// * `Failure` indicates an unrecoverable error. For example, when a prefix has been
<a href=#92 id=92 data-nosnippet>92</a>/// recognised and the next parser has been confirmed, if that parser fails, then the
<a href=#93 id=93 data-nosnippet>93</a>/// entire process fails; there are no more parsers to try.
<a href=#94 id=94 data-nosnippet>94</a>///
<a href=#95 id=95 data-nosnippet>95</a>/// Distinguishing `Failure` this from `Error` is only relevant inside the parser's code. For
<a href=#96 id=96 data-nosnippet>96</a>/// external consumers, both mean that parsing failed.
<a href=#97 id=97 data-nosnippet>97</a>///
<a href=#98 id=98 data-nosnippet>98</a>/// See also: [`Finish`].
<a href=#99 id=99 data-nosnippet>99</a>///
<a href=#100 id=100 data-nosnippet>100</a></span><span class="attr">#[derive(Debug, Clone, PartialEq)]
<a href=#101 id=101 data-nosnippet>101</a></span><span class="kw">pub enum </span><span class="prelude-val">Err</span>&lt;Failure, Error = Failure&gt; {
<a href=#102 id=102 data-nosnippet>102</a> <span class="doccomment">/// There was not enough data
<a href=#103 id=103 data-nosnippet>103</a> </span>Incomplete(Needed),
<a href=#104 id=104 data-nosnippet>104</a> <span class="doccomment">/// The parser had an error (recoverable)
<a href=#105 id=105 data-nosnippet>105</a> </span>Error(Error),
<a href=#106 id=106 data-nosnippet>106</a> <span class="doccomment">/// The parser had an unrecoverable error: we got to the right
<a href=#107 id=107 data-nosnippet>107</a> /// branch and we know other branches won't work, so backtrack
<a href=#108 id=108 data-nosnippet>108</a> /// as fast as possible
<a href=#109 id=109 data-nosnippet>109</a> </span>Failure(Failure),
<a href=#110 id=110 data-nosnippet>110</a>}
<a href=#111 id=111 data-nosnippet>111</a>
<a href=#112 id=112 data-nosnippet>112</a><span class="kw">impl</span>&lt;E&gt; <span class="prelude-val">Err</span>&lt;E&gt; {
<a href=#113 id=113 data-nosnippet>113</a> <span class="doccomment">/// Tests if the result is Incomplete
<a href=#114 id=114 data-nosnippet>114</a> </span><span class="kw">pub fn </span>is_incomplete(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; bool {
<a href=#115 id=115 data-nosnippet>115</a> <span class="macro">matches!</span>(<span class="self">self</span>, Err::Incomplete(..))
<a href=#116 id=116 data-nosnippet>116</a> }
<a href=#117 id=117 data-nosnippet>117</a>
<a href=#118 id=118 data-nosnippet>118</a> <span class="doccomment">/// Applies the given function to the inner error
<a href=#119 id=119 data-nosnippet>119</a> </span><span class="kw">pub fn </span>map&lt;E2, F&gt;(<span class="self">self</span>, f: F) -&gt; <span class="prelude-val">Err</span>&lt;E2&gt;
<a href=#120 id=120 data-nosnippet>120</a> <span class="kw">where
<a href=#121 id=121 data-nosnippet>121</a> </span>F: FnOnce(E) -&gt; E2,
<a href=#122 id=122 data-nosnippet>122</a> {
<a href=#123 id=123 data-nosnippet>123</a> <span class="kw">match </span><span class="self">self </span>{
<a href=#124 id=124 data-nosnippet>124</a> Err::Incomplete(n) =&gt; Err::Incomplete(n),
<a href=#125 id=125 data-nosnippet>125</a> Err::Failure(t) =&gt; Err::Failure(f(t)),
<a href=#126 id=126 data-nosnippet>126</a> Err::Error(t) =&gt; Err::Error(f(t)),
<a href=#127 id=127 data-nosnippet>127</a> }
<a href=#128 id=128 data-nosnippet>128</a> }
<a href=#129 id=129 data-nosnippet>129</a>
<a href=#130 id=130 data-nosnippet>130</a> <span class="doccomment">/// Automatically converts between errors if the underlying type supports it
<a href=#131 id=131 data-nosnippet>131</a> </span><span class="kw">pub fn </span>convert&lt;F&gt;(e: <span class="prelude-val">Err</span>&lt;F&gt;) -&gt; <span class="self">Self
<a href=#132 id=132 data-nosnippet>132</a> </span><span class="kw">where
<a href=#133 id=133 data-nosnippet>133</a> </span>E: From&lt;F&gt;,
<a href=#134 id=134 data-nosnippet>134</a> {
<a href=#135 id=135 data-nosnippet>135</a> e.map(<span class="kw">crate</span>::lib::std::convert::Into::into)
<a href=#136 id=136 data-nosnippet>136</a> }
<a href=#137 id=137 data-nosnippet>137</a>}
<a href=#138 id=138 data-nosnippet>138</a>
<a href=#139 id=139 data-nosnippet>139</a><span class="kw">impl</span>&lt;T&gt; <span class="prelude-val">Err</span>&lt;(T, ErrorKind)&gt; {
<a href=#140 id=140 data-nosnippet>140</a> <span class="doccomment">/// Maps `Err&lt;(T, ErrorKind)&gt;` to `Err&lt;(U, ErrorKind)&gt;` with the given `F: T -&gt; U`
<a href=#141 id=141 data-nosnippet>141</a> </span><span class="kw">pub fn </span>map_input&lt;U, F&gt;(<span class="self">self</span>, f: F) -&gt; <span class="prelude-val">Err</span>&lt;(U, ErrorKind)&gt;
<a href=#142 id=142 data-nosnippet>142</a> <span class="kw">where
<a href=#143 id=143 data-nosnippet>143</a> </span>F: FnOnce(T) -&gt; U,
<a href=#144 id=144 data-nosnippet>144</a> {
<a href=#145 id=145 data-nosnippet>145</a> <span class="kw">match </span><span class="self">self </span>{
<a href=#146 id=146 data-nosnippet>146</a> Err::Incomplete(n) =&gt; Err::Incomplete(n),
<a href=#147 id=147 data-nosnippet>147</a> Err::Failure((input, k)) =&gt; Err::Failure((f(input), k)),
<a href=#148 id=148 data-nosnippet>148</a> Err::Error((input, k)) =&gt; Err::Error((f(input), k)),
<a href=#149 id=149 data-nosnippet>149</a> }
<a href=#150 id=150 data-nosnippet>150</a> }
<a href=#151 id=151 data-nosnippet>151</a>}
<a href=#152 id=152 data-nosnippet>152</a>
<a href=#153 id=153 data-nosnippet>153</a><span class="kw">impl</span>&lt;T&gt; <span class="prelude-val">Err</span>&lt;error::Error&lt;T&gt;&gt; {
<a href=#154 id=154 data-nosnippet>154</a> <span class="doccomment">/// Maps `Err&lt;error::Error&lt;T&gt;&gt;` to `Err&lt;error::Error&lt;U&gt;&gt;` with the given `F: T -&gt; U`
<a href=#155 id=155 data-nosnippet>155</a> </span><span class="kw">pub fn </span>map_input&lt;U, F&gt;(<span class="self">self</span>, f: F) -&gt; <span class="prelude-val">Err</span>&lt;error::Error&lt;U&gt;&gt;
<a href=#156 id=156 data-nosnippet>156</a> <span class="kw">where
<a href=#157 id=157 data-nosnippet>157</a> </span>F: FnOnce(T) -&gt; U,
<a href=#158 id=158 data-nosnippet>158</a> {
<a href=#159 id=159 data-nosnippet>159</a> <span class="kw">match </span><span class="self">self </span>{
<a href=#160 id=160 data-nosnippet>160</a> Err::Incomplete(n) =&gt; Err::Incomplete(n),
<a href=#161 id=161 data-nosnippet>161</a> Err::Failure(error::Error { input, code }) =&gt; Err::Failure(error::Error {
<a href=#162 id=162 data-nosnippet>162</a> input: f(input),
<a href=#163 id=163 data-nosnippet>163</a> code,
<a href=#164 id=164 data-nosnippet>164</a> }),
<a href=#165 id=165 data-nosnippet>165</a> Err::Error(error::Error { input, code }) =&gt; Err::Error(error::Error {
<a href=#166 id=166 data-nosnippet>166</a> input: f(input),
<a href=#167 id=167 data-nosnippet>167</a> code,
<a href=#168 id=168 data-nosnippet>168</a> }),
<a href=#169 id=169 data-nosnippet>169</a> }
<a href=#170 id=170 data-nosnippet>170</a> }
<a href=#171 id=171 data-nosnippet>171</a>}
<a href=#172 id=172 data-nosnippet>172</a>
<a href=#173 id=173 data-nosnippet>173</a><span class="attr">#[cfg(feature = <span class="string">"alloc"</span>)]
<a href=#174 id=174 data-nosnippet>174</a></span><span class="kw">use </span><span class="kw">crate</span>::lib::std::{borrow::ToOwned, string::String, vec::Vec};
<a href=#175 id=175 data-nosnippet>175</a><span class="attr">#[cfg(feature = <span class="string">"alloc"</span>)]
<a href=#176 id=176 data-nosnippet>176</a></span><span class="kw">impl </span><span class="prelude-val">Err</span>&lt;(<span class="kw-2">&amp;</span>[u8], ErrorKind)&gt; {
<a href=#177 id=177 data-nosnippet>177</a> <span class="doccomment">/// Obtaining ownership
<a href=#178 id=178 data-nosnippet>178</a> </span><span class="attr">#[cfg_attr(feature = <span class="string">"docsrs"</span>, doc(cfg(feature = <span class="string">"alloc"</span>)))]
<a href=#179 id=179 data-nosnippet>179</a> </span><span class="kw">pub fn </span>to_owned(<span class="self">self</span>) -&gt; <span class="prelude-val">Err</span>&lt;(Vec&lt;u8&gt;, ErrorKind)&gt; {
<a href=#180 id=180 data-nosnippet>180</a> <span class="self">self</span>.map_input(ToOwned::to_owned)
<a href=#181 id=181 data-nosnippet>181</a> }
<a href=#182 id=182 data-nosnippet>182</a>}
<a href=#183 id=183 data-nosnippet>183</a>
<a href=#184 id=184 data-nosnippet>184</a><span class="attr">#[cfg(feature = <span class="string">"alloc"</span>)]
<a href=#185 id=185 data-nosnippet>185</a></span><span class="kw">impl </span><span class="prelude-val">Err</span>&lt;(<span class="kw-2">&amp;</span>str, ErrorKind)&gt; {
<a href=#186 id=186 data-nosnippet>186</a> <span class="doccomment">/// Obtaining ownership
<a href=#187 id=187 data-nosnippet>187</a> </span><span class="attr">#[cfg_attr(feature = <span class="string">"docsrs"</span>, doc(cfg(feature = <span class="string">"alloc"</span>)))]
<a href=#188 id=188 data-nosnippet>188</a> </span><span class="kw">pub fn </span>to_owned(<span class="self">self</span>) -&gt; <span class="prelude-val">Err</span>&lt;(String, ErrorKind)&gt; {
<a href=#189 id=189 data-nosnippet>189</a> <span class="self">self</span>.map_input(ToOwned::to_owned)
<a href=#190 id=190 data-nosnippet>190</a> }
<a href=#191 id=191 data-nosnippet>191</a>}
<a href=#192 id=192 data-nosnippet>192</a>
<a href=#193 id=193 data-nosnippet>193</a><span class="attr">#[cfg(feature = <span class="string">"alloc"</span>)]
<a href=#194 id=194 data-nosnippet>194</a></span><span class="kw">impl </span><span class="prelude-val">Err</span>&lt;error::Error&lt;<span class="kw-2">&amp;</span>[u8]&gt;&gt; {
<a href=#195 id=195 data-nosnippet>195</a> <span class="doccomment">/// Obtaining ownership
<a href=#196 id=196 data-nosnippet>196</a> </span><span class="attr">#[cfg_attr(feature = <span class="string">"docsrs"</span>, doc(cfg(feature = <span class="string">"alloc"</span>)))]
<a href=#197 id=197 data-nosnippet>197</a> </span><span class="kw">pub fn </span>to_owned(<span class="self">self</span>) -&gt; <span class="prelude-val">Err</span>&lt;error::Error&lt;Vec&lt;u8&gt;&gt;&gt; {
<a href=#198 id=198 data-nosnippet>198</a> <span class="self">self</span>.map_input(ToOwned::to_owned)
<a href=#199 id=199 data-nosnippet>199</a> }
<a href=#200 id=200 data-nosnippet>200</a>}
<a href=#201 id=201 data-nosnippet>201</a>
<a href=#202 id=202 data-nosnippet>202</a><span class="attr">#[cfg(feature = <span class="string">"alloc"</span>)]
<a href=#203 id=203 data-nosnippet>203</a></span><span class="kw">impl </span><span class="prelude-val">Err</span>&lt;error::Error&lt;<span class="kw-2">&amp;</span>str&gt;&gt; {
<a href=#204 id=204 data-nosnippet>204</a> <span class="doccomment">/// Obtaining ownership
<a href=#205 id=205 data-nosnippet>205</a> </span><span class="attr">#[cfg_attr(feature = <span class="string">"docsrs"</span>, doc(cfg(feature = <span class="string">"alloc"</span>)))]
<a href=#206 id=206 data-nosnippet>206</a> </span><span class="kw">pub fn </span>to_owned(<span class="self">self</span>) -&gt; <span class="prelude-val">Err</span>&lt;error::Error&lt;String&gt;&gt; {
<a href=#207 id=207 data-nosnippet>207</a> <span class="self">self</span>.map_input(ToOwned::to_owned)
<a href=#208 id=208 data-nosnippet>208</a> }
<a href=#209 id=209 data-nosnippet>209</a>}
<a href=#210 id=210 data-nosnippet>210</a>
<a href=#211 id=211 data-nosnippet>211</a><span class="kw">impl</span>&lt;E: Eq&gt; Eq <span class="kw">for </span><span class="prelude-val">Err</span>&lt;E&gt; {}
<a href=#212 id=212 data-nosnippet>212</a>
<a href=#213 id=213 data-nosnippet>213</a><span class="kw">impl</span>&lt;E&gt; fmt::Display <span class="kw">for </span><span class="prelude-val">Err</span>&lt;E&gt;
<a href=#214 id=214 data-nosnippet>214</a><span class="kw">where
<a href=#215 id=215 data-nosnippet>215</a> </span>E: fmt::Debug,
<a href=#216 id=216 data-nosnippet>216</a>{
<a href=#217 id=217 data-nosnippet>217</a> <span class="kw">fn </span>fmt(<span class="kw-2">&amp;</span><span class="self">self</span>, f: <span class="kw-2">&amp;mut </span>fmt::Formatter&lt;<span class="lifetime">'_</span>&gt;) -&gt; fmt::Result {
<a href=#218 id=218 data-nosnippet>218</a> <span class="kw">match </span><span class="self">self </span>{
<a href=#219 id=219 data-nosnippet>219</a> Err::Incomplete(Needed::Size(u)) =&gt; <span class="macro">write!</span>(f, <span class="string">"Parsing requires {} bytes/chars"</span>, u),
<a href=#220 id=220 data-nosnippet>220</a> Err::Incomplete(Needed::Unknown) =&gt; <span class="macro">write!</span>(f, <span class="string">"Parsing requires more data"</span>),
<a href=#221 id=221 data-nosnippet>221</a> Err::Failure(c) =&gt; <span class="macro">write!</span>(f, <span class="string">"Parsing Failure: {:?}"</span>, c),
<a href=#222 id=222 data-nosnippet>222</a> Err::Error(c) =&gt; <span class="macro">write!</span>(f, <span class="string">"Parsing Error: {:?}"</span>, c),
<a href=#223 id=223 data-nosnippet>223</a> }
<a href=#224 id=224 data-nosnippet>224</a> }
<a href=#225 id=225 data-nosnippet>225</a>}
<a href=#226 id=226 data-nosnippet>226</a>
<a href=#227 id=227 data-nosnippet>227</a><span class="attr">#[cfg(feature = <span class="string">"std"</span>)]
<a href=#228 id=228 data-nosnippet>228</a></span><span class="kw">use </span>std::error::Error;
<a href=#229 id=229 data-nosnippet>229</a>
<a href=#230 id=230 data-nosnippet>230</a><span class="attr">#[cfg(feature = <span class="string">"std"</span>)]
<a href=#231 id=231 data-nosnippet>231</a></span><span class="kw">impl</span>&lt;E&gt; Error <span class="kw">for </span><span class="prelude-val">Err</span>&lt;E&gt;
<a href=#232 id=232 data-nosnippet>232</a><span class="kw">where
<a href=#233 id=233 data-nosnippet>233</a> </span>E: fmt::Debug,
<a href=#234 id=234 data-nosnippet>234</a>{
<a href=#235 id=235 data-nosnippet>235</a> <span class="kw">fn </span>source(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; <span class="prelude-ty">Option</span>&lt;<span class="kw-2">&amp;</span>(<span class="kw">dyn </span>Error + <span class="lifetime">'static</span>)&gt; {
<a href=#236 id=236 data-nosnippet>236</a> <span class="prelude-val">None </span><span class="comment">// no underlying error
<a href=#237 id=237 data-nosnippet>237</a> </span>}
<a href=#238 id=238 data-nosnippet>238</a>}
<a href=#239 id=239 data-nosnippet>239</a>
<a href=#240 id=240 data-nosnippet>240</a><span class="doccomment">/// Parser mode: influences how combinators build values
<a href=#241 id=241 data-nosnippet>241</a>///
<a href=#242 id=242 data-nosnippet>242</a>/// the [Parser] trait is generic over types implementing [Mode]. Its method are
<a href=#243 id=243 data-nosnippet>243</a>/// called to produce and manipulate output values or errors.
<a href=#244 id=244 data-nosnippet>244</a>///
<a href=#245 id=245 data-nosnippet>245</a>/// The main implementations of this trait are:
<a href=#246 id=246 data-nosnippet>246</a>/// * [Emit]: produce a value
<a href=#247 id=247 data-nosnippet>247</a>/// * [Check]: apply the parser but do not generate a value
<a href=#248 id=248 data-nosnippet>248</a></span><span class="kw">pub trait </span>Mode {
<a href=#249 id=249 data-nosnippet>249</a> <span class="doccomment">/// The output type that may be generated
<a href=#250 id=250 data-nosnippet>250</a> </span><span class="kw">type </span>Output&lt;T&gt;;
<a href=#251 id=251 data-nosnippet>251</a>
<a href=#252 id=252 data-nosnippet>252</a> <span class="doccomment">/// Produces a value
<a href=#253 id=253 data-nosnippet>253</a> </span><span class="kw">fn </span>bind&lt;T, F: FnOnce() -&gt; T&gt;(f: F) -&gt; <span class="self">Self</span>::Output&lt;T&gt;;
<a href=#254 id=254 data-nosnippet>254</a>
<a href=#255 id=255 data-nosnippet>255</a> <span class="doccomment">/// Applies a function over the produced value
<a href=#256 id=256 data-nosnippet>256</a> </span><span class="kw">fn </span>map&lt;T, U, F: FnOnce(T) -&gt; U&gt;(x: <span class="self">Self</span>::Output&lt;T&gt;, f: F) -&gt; <span class="self">Self</span>::Output&lt;U&gt;;
<a href=#257 id=257 data-nosnippet>257</a>
<a href=#258 id=258 data-nosnippet>258</a> <span class="doccomment">/// Combines two values generated by previous parsers
<a href=#259 id=259 data-nosnippet>259</a> </span><span class="kw">fn </span>combine&lt;T, U, V, F: FnOnce(T, U) -&gt; V&gt;(
<a href=#260 id=260 data-nosnippet>260</a> x: <span class="self">Self</span>::Output&lt;T&gt;,
<a href=#261 id=261 data-nosnippet>261</a> y: <span class="self">Self</span>::Output&lt;U&gt;,
<a href=#262 id=262 data-nosnippet>262</a> f: F,
<a href=#263 id=263 data-nosnippet>263</a> ) -&gt; <span class="self">Self</span>::Output&lt;V&gt;;
<a href=#264 id=264 data-nosnippet>264</a>}
<a href=#265 id=265 data-nosnippet>265</a>
<a href=#266 id=266 data-nosnippet>266</a><span class="doccomment">/// Produces a value. This is the default behaviour for parsers
<a href=#267 id=267 data-nosnippet>267</a></span><span class="kw">pub struct </span>Emit;
<a href=#268 id=268 data-nosnippet>268</a><span class="kw">impl </span>Mode <span class="kw">for </span>Emit {
<a href=#269 id=269 data-nosnippet>269</a> <span class="kw">type </span>Output&lt;T&gt; = T;
<a href=#270 id=270 data-nosnippet>270</a>
<a href=#271 id=271 data-nosnippet>271</a> <span class="attr">#[inline(always)]
<a href=#272 id=272 data-nosnippet>272</a> </span><span class="kw">fn </span>bind&lt;T, F: FnOnce() -&gt; T&gt;(f: F) -&gt; <span class="self">Self</span>::Output&lt;T&gt; {
<a href=#273 id=273 data-nosnippet>273</a> f()
<a href=#274 id=274 data-nosnippet>274</a> }
<a href=#275 id=275 data-nosnippet>275</a>
<a href=#276 id=276 data-nosnippet>276</a> <span class="attr">#[inline(always)]
<a href=#277 id=277 data-nosnippet>277</a> </span><span class="kw">fn </span>map&lt;T, U, F: FnOnce(T) -&gt; U&gt;(x: <span class="self">Self</span>::Output&lt;T&gt;, f: F) -&gt; <span class="self">Self</span>::Output&lt;U&gt; {
<a href=#278 id=278 data-nosnippet>278</a> f(x)
<a href=#279 id=279 data-nosnippet>279</a> }
<a href=#280 id=280 data-nosnippet>280</a>
<a href=#281 id=281 data-nosnippet>281</a> <span class="attr">#[inline(always)]
<a href=#282 id=282 data-nosnippet>282</a> </span><span class="kw">fn </span>combine&lt;T, U, V, F: FnOnce(T, U) -&gt; V&gt;(
<a href=#283 id=283 data-nosnippet>283</a> x: <span class="self">Self</span>::Output&lt;T&gt;,
<a href=#284 id=284 data-nosnippet>284</a> y: <span class="self">Self</span>::Output&lt;U&gt;,
<a href=#285 id=285 data-nosnippet>285</a> f: F,
<a href=#286 id=286 data-nosnippet>286</a> ) -&gt; <span class="self">Self</span>::Output&lt;V&gt; {
<a href=#287 id=287 data-nosnippet>287</a> f(x, y)
<a href=#288 id=288 data-nosnippet>288</a> }
<a href=#289 id=289 data-nosnippet>289</a>}
<a href=#290 id=290 data-nosnippet>290</a>
<a href=#291 id=291 data-nosnippet>291</a><span class="doccomment">/// Applies the parser, but do not a produce a value
<a href=#292 id=292 data-nosnippet>292</a>///
<a href=#293 id=293 data-nosnippet>293</a>/// This has the effect of greatly reducing the amount of code generated and the
<a href=#294 id=294 data-nosnippet>294</a>/// parser memory usage. Some combinators check for an error in a child parser but
<a href=#295 id=295 data-nosnippet>295</a>/// discard the error, and for those, using [Check] makes sure the error is not
<a href=#296 id=296 data-nosnippet>296</a>/// even generated, only the fact that an error happened remains
<a href=#297 id=297 data-nosnippet>297</a></span><span class="kw">pub struct </span>Check;
<a href=#298 id=298 data-nosnippet>298</a><span class="kw">impl </span>Mode <span class="kw">for </span>Check {
<a href=#299 id=299 data-nosnippet>299</a> <span class="kw">type </span>Output&lt;T&gt; = ();
<a href=#300 id=300 data-nosnippet>300</a>
<a href=#301 id=301 data-nosnippet>301</a> <span class="attr">#[inline(always)]
<a href=#302 id=302 data-nosnippet>302</a> </span><span class="kw">fn </span>bind&lt;T, F: FnOnce() -&gt; T&gt;(<span class="kw">_</span>: F) -&gt; <span class="self">Self</span>::Output&lt;T&gt; {}
<a href=#303 id=303 data-nosnippet>303</a>
<a href=#304 id=304 data-nosnippet>304</a> <span class="attr">#[inline(always)]
<a href=#305 id=305 data-nosnippet>305</a> </span><span class="kw">fn </span>map&lt;T, U, F: FnOnce(T) -&gt; U&gt;(<span class="kw">_</span>: <span class="self">Self</span>::Output&lt;T&gt;, <span class="kw">_</span>: F) -&gt; <span class="self">Self</span>::Output&lt;U&gt; {}
<a href=#306 id=306 data-nosnippet>306</a>
<a href=#307 id=307 data-nosnippet>307</a> <span class="attr">#[inline(always)]
<a href=#308 id=308 data-nosnippet>308</a> </span><span class="kw">fn </span>combine&lt;T, U, V, F: FnOnce(T, U) -&gt; V&gt;(
<a href=#309 id=309 data-nosnippet>309</a> <span class="kw">_</span>: <span class="self">Self</span>::Output&lt;T&gt;,
<a href=#310 id=310 data-nosnippet>310</a> <span class="kw">_</span>: <span class="self">Self</span>::Output&lt;U&gt;,
<a href=#311 id=311 data-nosnippet>311</a> <span class="kw">_</span>: F,
<a href=#312 id=312 data-nosnippet>312</a> ) -&gt; <span class="self">Self</span>::Output&lt;V&gt; {
<a href=#313 id=313 data-nosnippet>313</a> }
<a href=#314 id=314 data-nosnippet>314</a>}
<a href=#315 id=315 data-nosnippet>315</a>
<a href=#316 id=316 data-nosnippet>316</a><span class="doccomment">/// Parser result type
<a href=#317 id=317 data-nosnippet>317</a>///
<a href=#318 id=318 data-nosnippet>318</a>/// * `Ok` branch: a tuple of the remaining input data, and the output value.
<a href=#319 id=319 data-nosnippet>319</a>/// The output value is of the `O` type if the output mode was [Emit], and `()`
<a href=#320 id=320 data-nosnippet>320</a>/// if the mode was [Check]
<a href=#321 id=321 data-nosnippet>321</a>/// * `Err` branch: an error of the `E` type if the erroor mode was [Emit], and `()`
<a href=#322 id=322 data-nosnippet>322</a>/// if the mode was [Check]
<a href=#323 id=323 data-nosnippet>323</a></span><span class="kw">pub type </span>PResult&lt;OM, I, O, E&gt; = <span class="prelude-ty">Result</span>&lt;
<a href=#324 id=324 data-nosnippet>324</a> (I, &lt;&lt;OM <span class="kw">as </span>OutputMode&gt;::Output <span class="kw">as </span>Mode&gt;::Output&lt;O&gt;),
<a href=#325 id=325 data-nosnippet>325</a> <span class="prelude-val">Err</span>&lt;E, &lt;&lt;OM <span class="kw">as </span>OutputMode&gt;::Error <span class="kw">as </span>Mode&gt;::Output&lt;E&gt;&gt;,
<a href=#326 id=326 data-nosnippet>326</a>&gt;;
<a href=#327 id=327 data-nosnippet>327</a>
<a href=#328 id=328 data-nosnippet>328</a><span class="doccomment">/// Trait Defining the parser's execution
<a href=#329 id=329 data-nosnippet>329</a>///
<a href=#330 id=330 data-nosnippet>330</a>/// The same parser implementation can vary in behaviour according to the chosen
<a href=#331 id=331 data-nosnippet>331</a>/// output mode
<a href=#332 id=332 data-nosnippet>332</a></span><span class="kw">pub trait </span>OutputMode {
<a href=#333 id=333 data-nosnippet>333</a> <span class="doccomment">/// Defines the [Mode] for the output type. [Emit] will generate the value, [Check] will
<a href=#334 id=334 data-nosnippet>334</a> /// apply the parser but will only generate `()` if successful. This can be used when
<a href=#335 id=335 data-nosnippet>335</a> /// verifying that the input data conforms to the format without having to generate any
<a href=#336 id=336 data-nosnippet>336</a> /// output data
<a href=#337 id=337 data-nosnippet>337</a> </span><span class="kw">type </span>Output: Mode;
<a href=#338 id=338 data-nosnippet>338</a> <span class="doccomment">/// Defines the [Mode] for the output type. [Emit] will generate the value, [Check] will
<a href=#339 id=339 data-nosnippet>339</a> /// apply the parser but will only generate `()` if an error happened. [Emit] should be
<a href=#340 id=340 data-nosnippet>340</a> /// used when we want to handle the error and extract useful information from it. [Check]
<a href=#341 id=341 data-nosnippet>341</a> /// is used when we just want to know if parsing failed and reject the data quickly.
<a href=#342 id=342 data-nosnippet>342</a> </span><span class="kw">type </span>Error: Mode;
<a href=#343 id=343 data-nosnippet>343</a> <span class="doccomment">/// Indicates whether the input data is "complete", ie we already have the entire data in the
<a href=#344 id=344 data-nosnippet>344</a> /// buffer, or if it is "streaming", where more data can be added later in the buffer. In
<a href=#345 id=345 data-nosnippet>345</a> /// streaming mode, the parser will understand that a failure may mean that we are missing
<a href=#346 id=346 data-nosnippet>346</a> /// data, and will return a specific error branch, [Err::Incomplete] to signal it. In complete
<a href=#347 id=347 data-nosnippet>347</a> /// mode, the parser will generate a normal error
<a href=#348 id=348 data-nosnippet>348</a> </span><span class="kw">type </span>Incomplete: IsStreaming;
<a href=#349 id=349 data-nosnippet>349</a>}
<a href=#350 id=350 data-nosnippet>350</a>
<a href=#351 id=351 data-nosnippet>351</a><span class="doccomment">/// Specifies the behaviour when a parser encounters an error that could be due to partial ata
<a href=#352 id=352 data-nosnippet>352</a></span><span class="kw">pub trait </span>IsStreaming {
<a href=#353 id=353 data-nosnippet>353</a> <span class="doccomment">/// called by parsers on partial data errors
<a href=#354 id=354 data-nosnippet>354</a> /// * `needed` can hold the amount of additional data the parser would need to decide
<a href=#355 id=355 data-nosnippet>355</a> /// * `err_f`: produces the error when in "complete" mode
<a href=#356 id=356 data-nosnippet>356</a> </span><span class="kw">fn </span>incomplete&lt;E, F: FnOnce() -&gt; E&gt;(needed: Needed, err_f: F) -&gt; <span class="prelude-val">Err</span>&lt;E&gt;;
<a href=#357 id=357 data-nosnippet>357</a> <span class="doccomment">/// Indicates whether the data is in streaming mode or not
<a href=#358 id=358 data-nosnippet>358</a> </span><span class="kw">fn </span>is_streaming() -&gt; bool;
<a href=#359 id=359 data-nosnippet>359</a>}
<a href=#360 id=360 data-nosnippet>360</a>
<a href=#361 id=361 data-nosnippet>361</a><span class="doccomment">/// Indicates that the input data is streaming: more data may be available later
<a href=#362 id=362 data-nosnippet>362</a></span><span class="kw">pub struct </span>Streaming;
<a href=#363 id=363 data-nosnippet>363</a>
<a href=#364 id=364 data-nosnippet>364</a><span class="kw">impl </span>IsStreaming <span class="kw">for </span>Streaming {
<a href=#365 id=365 data-nosnippet>365</a> <span class="kw">fn </span>incomplete&lt;E, F: FnOnce() -&gt; E&gt;(needed: Needed, _err_f: F) -&gt; <span class="prelude-val">Err</span>&lt;E&gt; {
<a href=#366 id=366 data-nosnippet>366</a> Err::Incomplete(needed)
<a href=#367 id=367 data-nosnippet>367</a> }
<a href=#368 id=368 data-nosnippet>368</a>
<a href=#369 id=369 data-nosnippet>369</a> <span class="attr">#[inline]
<a href=#370 id=370 data-nosnippet>370</a> </span><span class="kw">fn </span>is_streaming() -&gt; bool {
<a href=#371 id=371 data-nosnippet>371</a> <span class="bool-val">true
<a href=#372 id=372 data-nosnippet>372</a> </span>}
<a href=#373 id=373 data-nosnippet>373</a>}
<a href=#374 id=374 data-nosnippet>374</a>
<a href=#375 id=375 data-nosnippet>375</a><span class="doccomment">/// Indicates that the input data is complete: no more data may be added later
<a href=#376 id=376 data-nosnippet>376</a></span><span class="kw">pub struct </span>Complete;
<a href=#377 id=377 data-nosnippet>377</a>
<a href=#378 id=378 data-nosnippet>378</a><span class="kw">impl </span>IsStreaming <span class="kw">for </span>Complete {
<a href=#379 id=379 data-nosnippet>379</a> <span class="kw">fn </span>incomplete&lt;E, F: FnOnce() -&gt; E&gt;(_needed: Needed, err_f: F) -&gt; <span class="prelude-val">Err</span>&lt;E&gt; {
<a href=#380 id=380 data-nosnippet>380</a> Err::Error(err_f())
<a href=#381 id=381 data-nosnippet>381</a> }
<a href=#382 id=382 data-nosnippet>382</a>
<a href=#383 id=383 data-nosnippet>383</a> <span class="attr">#[inline]
<a href=#384 id=384 data-nosnippet>384</a> </span><span class="kw">fn </span>is_streaming() -&gt; bool {
<a href=#385 id=385 data-nosnippet>385</a> <span class="bool-val">false
<a href=#386 id=386 data-nosnippet>386</a> </span>}
<a href=#387 id=387 data-nosnippet>387</a>}
<a href=#388 id=388 data-nosnippet>388</a>
<a href=#389 id=389 data-nosnippet>389</a><span class="doccomment">/// Holds the parser execution modifiers: output [Mode], error [Mode] and
<a href=#390 id=390 data-nosnippet>390</a>/// streaming behaviour for input data
<a href=#391 id=391 data-nosnippet>391</a></span><span class="kw">pub struct </span>OutputM&lt;M: Mode, EM: Mode, S: IsStreaming&gt; {
<a href=#392 id=392 data-nosnippet>392</a> m: PhantomData&lt;M&gt;,
<a href=#393 id=393 data-nosnippet>393</a> em: PhantomData&lt;EM&gt;,
<a href=#394 id=394 data-nosnippet>394</a> s: PhantomData&lt;S&gt;,
<a href=#395 id=395 data-nosnippet>395</a>}
<a href=#396 id=396 data-nosnippet>396</a>
<a href=#397 id=397 data-nosnippet>397</a><span class="kw">impl</span>&lt;M: Mode, EM: Mode, S: IsStreaming&gt; OutputMode <span class="kw">for </span>OutputM&lt;M, EM, S&gt; {
<a href=#398 id=398 data-nosnippet>398</a> <span class="kw">type </span>Output = M;
<a href=#399 id=399 data-nosnippet>399</a> <span class="kw">type </span>Error = EM;
<a href=#400 id=400 data-nosnippet>400</a> <span class="kw">type </span>Incomplete = S;
<a href=#401 id=401 data-nosnippet>401</a>}
<a href=#402 id=402 data-nosnippet>402</a><span class="doccomment">/// All nom parsers implement this trait
<a href=#403 id=403 data-nosnippet>403</a></span><span class="kw">pub trait </span>Parser&lt;Input&gt; {
<a href=#404 id=404 data-nosnippet>404</a> <span class="doccomment">/// Type of the produced value
<a href=#405 id=405 data-nosnippet>405</a> </span><span class="kw">type </span>Output;
<a href=#406 id=406 data-nosnippet>406</a> <span class="doccomment">/// Error type of this parser
<a href=#407 id=407 data-nosnippet>407</a> </span><span class="kw">type </span>Error: ParseError&lt;Input&gt;;
<a href=#408 id=408 data-nosnippet>408</a>
<a href=#409 id=409 data-nosnippet>409</a> <span class="doccomment">/// A parser takes in input type, and returns a `Result` containing
<a href=#410 id=410 data-nosnippet>410</a> /// either the remaining input and the output value, or an error
<a href=#411 id=411 data-nosnippet>411</a> </span><span class="attr">#[inline]
<a href=#412 id=412 data-nosnippet>412</a> </span><span class="kw">fn </span>parse(<span class="kw-2">&amp;mut </span><span class="self">self</span>, input: Input) -&gt; IResult&lt;Input, <span class="self">Self</span>::Output, <span class="self">Self</span>::Error&gt; {
<a href=#413 id=413 data-nosnippet>413</a> <span class="self">self</span>.process::&lt;OutputM&lt;Emit, Emit, Streaming&gt;&gt;(input)
<a href=#414 id=414 data-nosnippet>414</a> }
<a href=#415 id=415 data-nosnippet>415</a>
<a href=#416 id=416 data-nosnippet>416</a> <span class="doccomment">/// A parser takes in input type, and returns a `Result` containing
<a href=#417 id=417 data-nosnippet>417</a> /// either the remaining input and the output value, or an error
<a href=#418 id=418 data-nosnippet>418</a> </span><span class="attr">#[inline]
<a href=#419 id=419 data-nosnippet>419</a> </span><span class="kw">fn </span>parse_complete(<span class="kw-2">&amp;mut </span><span class="self">self</span>, input: Input) -&gt; IResult&lt;Input, <span class="self">Self</span>::Output, <span class="self">Self</span>::Error&gt; {
<a href=#420 id=420 data-nosnippet>420</a> <span class="self">self</span>.process::&lt;OutputM&lt;Emit, Emit, Complete&gt;&gt;(input)
<a href=#421 id=421 data-nosnippet>421</a> }
<a href=#422 id=422 data-nosnippet>422</a>
<a href=#423 id=423 data-nosnippet>423</a> <span class="doccomment">/// A parser takes in input type, and returns a `Result` containing
<a href=#424 id=424 data-nosnippet>424</a> /// either the remaining input and the output value, or an error
<a href=#425 id=425 data-nosnippet>425</a> </span><span class="kw">fn </span>process&lt;OM: OutputMode&gt;(
<a href=#426 id=426 data-nosnippet>426</a> <span class="kw-2">&amp;mut </span><span class="self">self</span>,
<a href=#427 id=427 data-nosnippet>427</a> input: Input,
<a href=#428 id=428 data-nosnippet>428</a> ) -&gt; PResult&lt;OM, Input, <span class="self">Self</span>::Output, <span class="self">Self</span>::Error&gt;;
<a href=#429 id=429 data-nosnippet>429</a>
<a href=#430 id=430 data-nosnippet>430</a> <span class="doccomment">/// Maps a function over the result of a parser
<a href=#431 id=431 data-nosnippet>431</a> </span><span class="kw">fn </span>map&lt;G, O2&gt;(<span class="self">self</span>, g: G) -&gt; Map&lt;<span class="self">Self</span>, G&gt;
<a href=#432 id=432 data-nosnippet>432</a> <span class="kw">where
<a href=#433 id=433 data-nosnippet>433</a> </span>G: FnMut(<span class="self">Self</span>::Output) -&gt; O2,
<a href=#434 id=434 data-nosnippet>434</a> <span class="self">Self</span>: core::marker::Sized,
<a href=#435 id=435 data-nosnippet>435</a> {
<a href=#436 id=436 data-nosnippet>436</a> Map { f: <span class="self">self</span>, g }
<a href=#437 id=437 data-nosnippet>437</a> }
<a href=#438 id=438 data-nosnippet>438</a>
<a href=#439 id=439 data-nosnippet>439</a> <span class="doccomment">/// Applies a function returning a `Result` over the result of a parser.
<a href=#440 id=440 data-nosnippet>440</a> </span><span class="kw">fn </span>map_res&lt;G, O2, E2&gt;(<span class="self">self</span>, g: G) -&gt; MapRes&lt;<span class="self">Self</span>, G&gt;
<a href=#441 id=441 data-nosnippet>441</a> <span class="kw">where
<a href=#442 id=442 data-nosnippet>442</a> </span>G: FnMut(<span class="self">Self</span>::Output) -&gt; <span class="prelude-ty">Result</span>&lt;O2, E2&gt;,
<a href=#443 id=443 data-nosnippet>443</a> <span class="self">Self</span>::Error: FromExternalError&lt;Input, E2&gt;,
<a href=#444 id=444 data-nosnippet>444</a> <span class="self">Self</span>: core::marker::Sized,
<a href=#445 id=445 data-nosnippet>445</a> {
<a href=#446 id=446 data-nosnippet>446</a> MapRes { f: <span class="self">self</span>, g }
<a href=#447 id=447 data-nosnippet>447</a> }
<a href=#448 id=448 data-nosnippet>448</a>
<a href=#449 id=449 data-nosnippet>449</a> <span class="doccomment">/// Applies a function returning an `Option` over the result of a parser.
<a href=#450 id=450 data-nosnippet>450</a> </span><span class="kw">fn </span>map_opt&lt;G, O2&gt;(<span class="self">self</span>, g: G) -&gt; MapOpt&lt;<span class="self">Self</span>, G&gt;
<a href=#451 id=451 data-nosnippet>451</a> <span class="kw">where
<a href=#452 id=452 data-nosnippet>452</a> </span>G: FnMut(<span class="self">Self</span>::Output) -&gt; <span class="prelude-ty">Option</span>&lt;O2&gt;,
<a href=#453 id=453 data-nosnippet>453</a> <span class="self">Self</span>: core::marker::Sized,
<a href=#454 id=454 data-nosnippet>454</a> {
<a href=#455 id=455 data-nosnippet>455</a> MapOpt { f: <span class="self">self</span>, g }
<a href=#456 id=456 data-nosnippet>456</a> }
<a href=#457 id=457 data-nosnippet>457</a>
<a href=#458 id=458 data-nosnippet>458</a> <span class="doccomment">/// Creates a second parser from the output of the first one, then apply over the rest of the input
<a href=#459 id=459 data-nosnippet>459</a> </span><span class="kw">fn </span>flat_map&lt;G, H&gt;(<span class="self">self</span>, g: G) -&gt; FlatMap&lt;<span class="self">Self</span>, G&gt;
<a href=#460 id=460 data-nosnippet>460</a> <span class="kw">where
<a href=#461 id=461 data-nosnippet>461</a> </span>G: FnMut(<span class="self">Self</span>::Output) -&gt; H,
<a href=#462 id=462 data-nosnippet>462</a> H: Parser&lt;Input, Error = <span class="self">Self</span>::Error&gt;,
<a href=#463 id=463 data-nosnippet>463</a> <span class="self">Self</span>: core::marker::Sized,
<a href=#464 id=464 data-nosnippet>464</a> {
<a href=#465 id=465 data-nosnippet>465</a> FlatMap { f: <span class="self">self</span>, g }
<a href=#466 id=466 data-nosnippet>466</a> }
<a href=#467 id=467 data-nosnippet>467</a>
<a href=#468 id=468 data-nosnippet>468</a> <span class="doccomment">/// Applies a second parser over the output of the first one
<a href=#469 id=469 data-nosnippet>469</a> </span><span class="kw">fn </span>and_then&lt;G&gt;(<span class="self">self</span>, g: G) -&gt; AndThen&lt;<span class="self">Self</span>, G&gt;
<a href=#470 id=470 data-nosnippet>470</a> <span class="kw">where
<a href=#471 id=471 data-nosnippet>471</a> </span>G: Parser&lt;<span class="self">Self</span>::Output, Error = <span class="self">Self</span>::Error&gt;,
<a href=#472 id=472 data-nosnippet>472</a> <span class="self">Self</span>: core::marker::Sized,
<a href=#473 id=473 data-nosnippet>473</a> {
<a href=#474 id=474 data-nosnippet>474</a> AndThen { f: <span class="self">self</span>, g }
<a href=#475 id=475 data-nosnippet>475</a> }
<a href=#476 id=476 data-nosnippet>476</a>
<a href=#477 id=477 data-nosnippet>477</a> <span class="doccomment">/// Applies a second parser after the first one, return their results as a tuple
<a href=#478 id=478 data-nosnippet>478</a> </span><span class="kw">fn </span>and&lt;G, O2&gt;(<span class="self">self</span>, g: G) -&gt; And&lt;<span class="self">Self</span>, G&gt;
<a href=#479 id=479 data-nosnippet>479</a> <span class="kw">where
<a href=#480 id=480 data-nosnippet>480</a> </span>G: Parser&lt;Input, Output = O2, Error = <span class="self">Self</span>::Error&gt;,
<a href=#481 id=481 data-nosnippet>481</a> <span class="self">Self</span>: core::marker::Sized,
<a href=#482 id=482 data-nosnippet>482</a> {
<a href=#483 id=483 data-nosnippet>483</a> And { f: <span class="self">self</span>, g }
<a href=#484 id=484 data-nosnippet>484</a> }
<a href=#485 id=485 data-nosnippet>485</a>
<a href=#486 id=486 data-nosnippet>486</a> <span class="doccomment">/// Applies a second parser over the input if the first one failed
<a href=#487 id=487 data-nosnippet>487</a> </span><span class="kw">fn </span>or&lt;G&gt;(<span class="self">self</span>, g: G) -&gt; Or&lt;<span class="self">Self</span>, G&gt;
<a href=#488 id=488 data-nosnippet>488</a> <span class="kw">where
<a href=#489 id=489 data-nosnippet>489</a> </span>G: Parser&lt;Input, Output = <span class="self">Self</span>::Output, Error = <span class="self">Self</span>::Error&gt;,
<a href=#490 id=490 data-nosnippet>490</a> <span class="self">Self</span>: core::marker::Sized,
<a href=#491 id=491 data-nosnippet>491</a> {
<a href=#492 id=492 data-nosnippet>492</a> Or { f: <span class="self">self</span>, g }
<a href=#493 id=493 data-nosnippet>493</a> }
<a href=#494 id=494 data-nosnippet>494</a>
<a href=#495 id=495 data-nosnippet>495</a> <span class="doccomment">/// automatically converts the parser's output and error values to another type, as long as they
<a href=#496 id=496 data-nosnippet>496</a> /// implement the `From` trait
<a href=#497 id=497 data-nosnippet>497</a> </span><span class="kw">fn </span>into&lt;O2: From&lt;<span class="self">Self</span>::Output&gt;, E2: From&lt;<span class="self">Self</span>::Error&gt;&gt;(<span class="self">self</span>) -&gt; Into&lt;<span class="self">Self</span>, O2, E2&gt;
<a href=#498 id=498 data-nosnippet>498</a> <span class="kw">where
<a href=#499 id=499 data-nosnippet>499</a> </span><span class="self">Self</span>: core::marker::Sized,
<a href=#500 id=500 data-nosnippet>500</a> {
<a href=#501 id=501 data-nosnippet>501</a> Into {
<a href=#502 id=502 data-nosnippet>502</a> f: <span class="self">self</span>,
<a href=#503 id=503 data-nosnippet>503</a> phantom_out2: core::marker::PhantomData,
<a href=#504 id=504 data-nosnippet>504</a> phantom_err2: core::marker::PhantomData,
<a href=#505 id=505 data-nosnippet>505</a> }
<a href=#506 id=506 data-nosnippet>506</a> }
<a href=#507 id=507 data-nosnippet>507</a>}
<a href=#508 id=508 data-nosnippet>508</a>
<a href=#509 id=509 data-nosnippet>509</a><span class="kw">impl</span>&lt;I, O, E: ParseError&lt;I&gt;, F&gt; Parser&lt;I&gt; <span class="kw">for </span>F
<a href=#510 id=510 data-nosnippet>510</a><span class="kw">where
<a href=#511 id=511 data-nosnippet>511</a> </span>F: FnMut(I) -&gt; IResult&lt;I, O, E&gt;,
<a href=#512 id=512 data-nosnippet>512</a>{
<a href=#513 id=513 data-nosnippet>513</a> <span class="kw">type </span>Output = O;
<a href=#514 id=514 data-nosnippet>514</a> <span class="kw">type </span>Error = E;
<a href=#515 id=515 data-nosnippet>515</a>
<a href=#516 id=516 data-nosnippet>516</a> <span class="kw">fn </span>process&lt;OM: OutputMode&gt;(<span class="kw-2">&amp;mut </span><span class="self">self</span>, i: I) -&gt; PResult&lt;OM, I, <span class="self">Self</span>::Output, <span class="self">Self</span>::Error&gt; {
<a href=#517 id=517 data-nosnippet>517</a> <span class="kw">let </span>(i, o) = <span class="self">self</span>(i).map_err(|e| <span class="kw">match </span>e {
<a href=#518 id=518 data-nosnippet>518</a> Err::Incomplete(i) =&gt; Err::Incomplete(i),
<a href=#519 id=519 data-nosnippet>519</a> Err::Error(e) =&gt; Err::Error(OM::Error::bind(|| e)),
<a href=#520 id=520 data-nosnippet>520</a> Err::Failure(e) =&gt; Err::Failure(e),
<a href=#521 id=521 data-nosnippet>521</a> })<span class="question-mark">?</span>;
<a href=#522 id=522 data-nosnippet>522</a> <span class="prelude-val">Ok</span>((i, OM::Output::bind(|| o)))
<a href=#523 id=523 data-nosnippet>523</a> }
<a href=#524 id=524 data-nosnippet>524</a>}
<a href=#525 id=525 data-nosnippet>525</a>
<a href=#526 id=526 data-nosnippet>526</a><span class="macro">macro_rules!</span> impl_parser_for_tuple {
<a href=#527 id=527 data-nosnippet>527</a> ($(<span class="macro-nonterminal">$parser</span>:ident <span class="macro-nonterminal">$output</span>:ident),+) =&gt; (
<a href=#528 id=528 data-nosnippet>528</a> <span class="attr">#[allow(non_snake_case)]
<a href=#529 id=529 data-nosnippet>529</a> </span><span class="kw">impl</span>&lt;I, $(<span class="macro-nonterminal">$output</span>),+, E: ParseError&lt;I&gt;, $(<span class="macro-nonterminal">$parser</span>),+&gt; Parser&lt;I&gt; <span class="kw">for </span>($(<span class="macro-nonterminal">$parser</span>),+,)
<a href=#530 id=530 data-nosnippet>530</a> <span class="kw">where
<a href=#531 id=531 data-nosnippet>531</a> </span>$(<span class="macro-nonterminal">$parser</span>: Parser&lt;I, Output = <span class="macro-nonterminal">$output</span>, Error = E&gt;),+
<a href=#532 id=532 data-nosnippet>532</a> {
<a href=#533 id=533 data-nosnippet>533</a> <span class="kw">type </span>Output = ($(<span class="macro-nonterminal">$output</span>),+,);
<a href=#534 id=534 data-nosnippet>534</a> <span class="kw">type </span>Error = E;
<a href=#535 id=535 data-nosnippet>535</a>
<a href=#536 id=536 data-nosnippet>536</a> <span class="attr">#[inline(always)]
<a href=#537 id=537 data-nosnippet>537</a> </span><span class="kw">fn </span>process&lt;OM: OutputMode&gt;(<span class="kw-2">&amp;mut </span><span class="self">self</span>, i: I) -&gt; PResult&lt;OM, I, <span class="self">Self</span>::Output, <span class="self">Self</span>::Error&gt; {
<a href=#538 id=538 data-nosnippet>538</a> <span class="kw">let </span>($(<span class="kw-2">ref mut </span><span class="macro-nonterminal">$parser</span>),+,) = <span class="kw-2">*</span><span class="self">self</span>;
<a href=#539 id=539 data-nosnippet>539</a>
<a href=#540 id=540 data-nosnippet>540</a> <span class="comment">// FIXME: is there a way to avoid producing the output values?
<a href=#541 id=541 data-nosnippet>541</a> </span>$(<span class="kw">let</span>(i, <span class="macro-nonterminal">$output</span>) = <span class="macro-nonterminal">$parser</span>.process::&lt;OutputM&lt;Emit, OM::Error, OM::Incomplete&gt;&gt;(i)<span class="question-mark">?</span>;)+
<a href=#542 id=542 data-nosnippet>542</a>
<a href=#543 id=543 data-nosnippet>543</a> <span class="comment">// ???
<a href=#544 id=544 data-nosnippet>544</a> </span><span class="prelude-val">Ok</span>((i, OM::Output::bind(|| ($(<span class="macro-nonterminal">$output</span>),+,))))
<a href=#545 id=545 data-nosnippet>545</a> }
<a href=#546 id=546 data-nosnippet>546</a> }
<a href=#547 id=547 data-nosnippet>547</a> )
<a href=#548 id=548 data-nosnippet>548</a>}
<a href=#549 id=549 data-nosnippet>549</a>
<a href=#550 id=550 data-nosnippet>550</a><span class="macro">macro_rules!</span> impl_parser_for_tuples {
<a href=#551 id=551 data-nosnippet>551</a> (<span class="macro-nonterminal">$parser1</span>:ident <span class="macro-nonterminal">$output1</span>:ident, $(<span class="macro-nonterminal">$parser</span>:ident <span class="macro-nonterminal">$output</span>:ident),+) =&gt; {
<a href=#552 id=552 data-nosnippet>552</a> <span class="macro">impl_parser_for_tuples!</span>(__impl <span class="macro-nonterminal">$parser1 $output1</span>; $(<span class="macro-nonterminal">$parser $output</span>),+);
<a href=#553 id=553 data-nosnippet>553</a> };
<a href=#554 id=554 data-nosnippet>554</a> (__impl $(<span class="macro-nonterminal">$parser</span>:ident <span class="macro-nonterminal">$output</span>:ident),+; <span class="macro-nonterminal">$parser1</span>:ident <span class="macro-nonterminal">$output1</span>:ident $(,<span class="macro-nonterminal">$parser2</span>:ident <span class="macro-nonterminal">$output2</span>:ident)<span class="kw-2">*</span>) =&gt; {
<a href=#555 id=555 data-nosnippet>555</a> <span class="macro">impl_parser_for_tuple!</span>($(<span class="macro-nonterminal">$parser $output</span>),+);
<a href=#556 id=556 data-nosnippet>556</a> <span class="macro">impl_parser_for_tuples!</span>(__impl $(<span class="macro-nonterminal">$parser $output</span>),+, <span class="macro-nonterminal">$parser1 $output1</span>; $(<span class="macro-nonterminal">$parser2 $output2</span>),<span class="kw-2">*</span>);
<a href=#557 id=557 data-nosnippet>557</a> };
<a href=#558 id=558 data-nosnippet>558</a> (__impl $(<span class="macro-nonterminal">$parser</span>:ident <span class="macro-nonterminal">$output</span>:ident),+;) =&gt; {
<a href=#559 id=559 data-nosnippet>559</a> <span class="macro">impl_parser_for_tuple!</span>($(<span class="macro-nonterminal">$parser $output</span>),+);
<a href=#560 id=560 data-nosnippet>560</a> }
<a href=#561 id=561 data-nosnippet>561</a>}
<a href=#562 id=562 data-nosnippet>562</a>
<a href=#563 id=563 data-nosnippet>563</a><span class="macro">impl_parser_for_tuples!</span>(P1 O1, P2 O2, P3 O3, P4 O4, P5 O5, P6 O6, P7 O7, P8 O8, P9 O9, P10 O10, P11 O11, P12 O12, P13 O13, P14 O14, P15 O15, P16 O16, P17 O17, P18 O18, P19 O19, P20 O20, P21 O21);
<a href=#564 id=564 data-nosnippet>564</a>
<a href=#565 id=565 data-nosnippet>565</a><span class="comment">/*
<a href=#566 id=566 data-nosnippet>566</a>#[cfg(feature = "alloc")]
<a href=#567 id=567 data-nosnippet>567</a>use alloc::boxed::Box;
<a href=#568 id=568 data-nosnippet>568</a>
<a href=#569 id=569 data-nosnippet>569</a>#[cfg(feature = "alloc")]
<a href=#570 id=570 data-nosnippet>570</a>impl&lt;I, O, E: ParseError&lt;I&gt;&gt; Parser&lt;I&gt; for Box&lt;dyn Parser&lt;I, Output = O, Error = E&gt;&gt; {
<a href=#571 id=571 data-nosnippet>571</a> type Output = O;
<a href=#572 id=572 data-nosnippet>572</a> type Error = E;
<a href=#573 id=573 data-nosnippet>573</a>
<a href=#574 id=574 data-nosnippet>574</a> fn process&lt;OM: OutputMode&gt;(&amp;mut self, input: I) -&gt; PResult&lt;OM, I, Self::Output, Self::Error&gt; {
<a href=#575 id=575 data-nosnippet>575</a> (**self).process(input)
<a href=#576 id=576 data-nosnippet>576</a> }
<a href=#577 id=577 data-nosnippet>577</a>}
<a href=#578 id=578 data-nosnippet>578</a>*/
<a href=#579 id=579 data-nosnippet>579</a></span><span class="doccomment">/// Implementation of `Parser::map`
<a href=#580 id=580 data-nosnippet>580</a></span><span class="kw">pub struct </span>Map&lt;F, G&gt; {
<a href=#581 id=581 data-nosnippet>581</a> f: F,
<a href=#582 id=582 data-nosnippet>582</a> g: G,
<a href=#583 id=583 data-nosnippet>583</a>}
<a href=#584 id=584 data-nosnippet>584</a>
<a href=#585 id=585 data-nosnippet>585</a><span class="kw">impl</span>&lt;I, O2, E: ParseError&lt;I&gt;, F: Parser&lt;I, Error = E&gt;, G: FnMut(&lt;F <span class="kw">as </span>Parser&lt;I&gt;&gt;::Output) -&gt; O2&gt;
<a href=#586 id=586 data-nosnippet>586</a> Parser&lt;I&gt; <span class="kw">for </span>Map&lt;F, G&gt;
<a href=#587 id=587 data-nosnippet>587</a>{
<a href=#588 id=588 data-nosnippet>588</a> <span class="kw">type </span>Output = O2;
<a href=#589 id=589 data-nosnippet>589</a> <span class="kw">type </span>Error = E;
<a href=#590 id=590 data-nosnippet>590</a>
<a href=#591 id=591 data-nosnippet>591</a> <span class="attr">#[inline(always)]
<a href=#592 id=592 data-nosnippet>592</a> </span><span class="kw">fn </span>process&lt;OM: OutputMode&gt;(<span class="kw-2">&amp;mut </span><span class="self">self</span>, i: I) -&gt; PResult&lt;OM, I, <span class="self">Self</span>::Output, <span class="self">Self</span>::Error&gt; {
<a href=#593 id=593 data-nosnippet>593</a> <span class="kw">match </span><span class="self">self</span>.f.process::&lt;OM&gt;(i) {
<a href=#594 id=594 data-nosnippet>594</a> <span class="prelude-val">Err</span>(e) =&gt; <span class="prelude-val">Err</span>(e),
<a href=#595 id=595 data-nosnippet>595</a> <span class="prelude-val">Ok</span>((i, o)) =&gt; <span class="prelude-val">Ok</span>((i, OM::Output::map(o, |o| (<span class="self">self</span>.g)(o)))),
<a href=#596 id=596 data-nosnippet>596</a> }
<a href=#597 id=597 data-nosnippet>597</a> }
<a href=#598 id=598 data-nosnippet>598</a>}
<a href=#599 id=599 data-nosnippet>599</a>
<a href=#600 id=600 data-nosnippet>600</a><span class="doccomment">/// Implementation of `Parser::map_res`
<a href=#601 id=601 data-nosnippet>601</a></span><span class="kw">pub struct </span>MapRes&lt;F, G&gt; {
<a href=#602 id=602 data-nosnippet>602</a> f: F,
<a href=#603 id=603 data-nosnippet>603</a> g: G,
<a href=#604 id=604 data-nosnippet>604</a>}
<a href=#605 id=605 data-nosnippet>605</a>
<a href=#606 id=606 data-nosnippet>606</a><span class="kw">impl</span>&lt;I, O2, E2, F, G&gt; Parser&lt;I&gt; <span class="kw">for </span>MapRes&lt;F, G&gt;
<a href=#607 id=607 data-nosnippet>607</a><span class="kw">where
<a href=#608 id=608 data-nosnippet>608</a> </span>I: Clone,
<a href=#609 id=609 data-nosnippet>609</a> &lt;F <span class="kw">as </span>Parser&lt;I&gt;&gt;::Error: FromExternalError&lt;I, E2&gt;,
<a href=#610 id=610 data-nosnippet>610</a> F: Parser&lt;I&gt;,
<a href=#611 id=611 data-nosnippet>611</a> G: FnMut(&lt;F <span class="kw">as </span>Parser&lt;I&gt;&gt;::Output) -&gt; <span class="prelude-ty">Result</span>&lt;O2, E2&gt;,
<a href=#612 id=612 data-nosnippet>612</a>{
<a href=#613 id=613 data-nosnippet>613</a> <span class="kw">type </span>Output = O2;
<a href=#614 id=614 data-nosnippet>614</a> <span class="kw">type </span>Error = &lt;F <span class="kw">as </span>Parser&lt;I&gt;&gt;::Error;
<a href=#615 id=615 data-nosnippet>615</a>
<a href=#616 id=616 data-nosnippet>616</a> <span class="kw">fn </span>process&lt;OM: OutputMode&gt;(<span class="kw-2">&amp;mut </span><span class="self">self</span>, i: I) -&gt; PResult&lt;OM, I, <span class="self">Self</span>::Output, <span class="self">Self</span>::Error&gt; {
<a href=#617 id=617 data-nosnippet>617</a> <span class="kw">let </span>(input, o1) = <span class="self">self
<a href=#618 id=618 data-nosnippet>618</a> </span>.f
<a href=#619 id=619 data-nosnippet>619</a> .process::&lt;OutputM&lt;Emit, OM::Error, OM::Incomplete&gt;&gt;(i.clone())<span class="question-mark">?</span>;
<a href=#620 id=620 data-nosnippet>620</a>
<a href=#621 id=621 data-nosnippet>621</a> <span class="kw">match </span>(<span class="self">self</span>.g)(o1) {
<a href=#622 id=622 data-nosnippet>622</a> <span class="prelude-val">Ok</span>(o2) =&gt; <span class="prelude-val">Ok</span>((input, OM::Output::bind(|| o2))),
<a href=#623 id=623 data-nosnippet>623</a> <span class="prelude-val">Err</span>(e) =&gt; <span class="prelude-val">Err</span>(Err::Error(OM::Error::bind(|| {
<a href=#624 id=624 data-nosnippet>624</a> &lt;F <span class="kw">as </span>Parser&lt;I&gt;&gt;::Error::from_external_error(i, ErrorKind::MapRes, e)
<a href=#625 id=625 data-nosnippet>625</a> }))),
<a href=#626 id=626 data-nosnippet>626</a> }
<a href=#627 id=627 data-nosnippet>627</a> }
<a href=#628 id=628 data-nosnippet>628</a>}
<a href=#629 id=629 data-nosnippet>629</a>
<a href=#630 id=630 data-nosnippet>630</a><span class="doccomment">/// Implementation of `Parser::map_opt`
<a href=#631 id=631 data-nosnippet>631</a></span><span class="kw">pub struct </span>MapOpt&lt;F, G&gt; {
<a href=#632 id=632 data-nosnippet>632</a> f: F,
<a href=#633 id=633 data-nosnippet>633</a> g: G,
<a href=#634 id=634 data-nosnippet>634</a>}
<a href=#635 id=635 data-nosnippet>635</a>
<a href=#636 id=636 data-nosnippet>636</a><span class="kw">impl</span>&lt;I, O2, F, G&gt; Parser&lt;I&gt; <span class="kw">for </span>MapOpt&lt;F, G&gt;
<a href=#637 id=637 data-nosnippet>637</a><span class="kw">where
<a href=#638 id=638 data-nosnippet>638</a> </span>I: Clone,
<a href=#639 id=639 data-nosnippet>639</a> F: Parser&lt;I&gt;,
<a href=#640 id=640 data-nosnippet>640</a> G: FnMut(&lt;F <span class="kw">as </span>Parser&lt;I&gt;&gt;::Output) -&gt; <span class="prelude-ty">Option</span>&lt;O2&gt;,
<a href=#641 id=641 data-nosnippet>641</a>{
<a href=#642 id=642 data-nosnippet>642</a> <span class="kw">type </span>Output = O2;
<a href=#643 id=643 data-nosnippet>643</a> <span class="kw">type </span>Error = &lt;F <span class="kw">as </span>Parser&lt;I&gt;&gt;::Error;
<a href=#644 id=644 data-nosnippet>644</a>
<a href=#645 id=645 data-nosnippet>645</a> <span class="kw">fn </span>process&lt;OM: OutputMode&gt;(<span class="kw-2">&amp;mut </span><span class="self">self</span>, i: I) -&gt; PResult&lt;OM, I, <span class="self">Self</span>::Output, <span class="self">Self</span>::Error&gt; {
<a href=#646 id=646 data-nosnippet>646</a> <span class="kw">let </span>(input, o1) = <span class="self">self
<a href=#647 id=647 data-nosnippet>647</a> </span>.f
<a href=#648 id=648 data-nosnippet>648</a> .process::&lt;OutputM&lt;Emit, OM::Error, OM::Incomplete&gt;&gt;(i.clone())<span class="question-mark">?</span>;
<a href=#649 id=649 data-nosnippet>649</a>
<a href=#650 id=650 data-nosnippet>650</a> <span class="kw">match </span>(<span class="self">self</span>.g)(o1) {
<a href=#651 id=651 data-nosnippet>651</a> <span class="prelude-val">Some</span>(o2) =&gt; <span class="prelude-val">Ok</span>((input, OM::Output::bind(|| o2))),
<a href=#652 id=652 data-nosnippet>652</a> <span class="prelude-val">None </span>=&gt; <span class="prelude-val">Err</span>(Err::Error(OM::Error::bind(|| {
<a href=#653 id=653 data-nosnippet>653</a> &lt;F <span class="kw">as </span>Parser&lt;I&gt;&gt;::Error::from_error_kind(i, ErrorKind::MapOpt)
<a href=#654 id=654 data-nosnippet>654</a> }))),
<a href=#655 id=655 data-nosnippet>655</a> }
<a href=#656 id=656 data-nosnippet>656</a> }
<a href=#657 id=657 data-nosnippet>657</a>}
<a href=#658 id=658 data-nosnippet>658</a>
<a href=#659 id=659 data-nosnippet>659</a><span class="doccomment">/// Implementation of `Parser::flat_map`
<a href=#660 id=660 data-nosnippet>660</a></span><span class="kw">pub struct </span>FlatMap&lt;F, G&gt; {
<a href=#661 id=661 data-nosnippet>661</a> f: F,
<a href=#662 id=662 data-nosnippet>662</a> g: G,
<a href=#663 id=663 data-nosnippet>663</a>}
<a href=#664 id=664 data-nosnippet>664</a>
<a href=#665 id=665 data-nosnippet>665</a><span class="kw">impl</span>&lt;
<a href=#666 id=666 data-nosnippet>666</a> I,
<a href=#667 id=667 data-nosnippet>667</a> E: ParseError&lt;I&gt;,
<a href=#668 id=668 data-nosnippet>668</a> F: Parser&lt;I, Error = E&gt;,
<a href=#669 id=669 data-nosnippet>669</a> G: FnMut(&lt;F <span class="kw">as </span>Parser&lt;I&gt;&gt;::Output) -&gt; H,
<a href=#670 id=670 data-nosnippet>670</a> H: Parser&lt;I, Error = E&gt;,
<a href=#671 id=671 data-nosnippet>671</a> &gt; Parser&lt;I&gt; <span class="kw">for </span>FlatMap&lt;F, G&gt;
<a href=#672 id=672 data-nosnippet>672</a>{
<a href=#673 id=673 data-nosnippet>673</a> <span class="kw">type </span>Output = &lt;H <span class="kw">as </span>Parser&lt;I&gt;&gt;::Output;
<a href=#674 id=674 data-nosnippet>674</a> <span class="kw">type </span>Error = E;
<a href=#675 id=675 data-nosnippet>675</a>
<a href=#676 id=676 data-nosnippet>676</a> <span class="kw">fn </span>process&lt;OM: OutputMode&gt;(<span class="kw-2">&amp;mut </span><span class="self">self</span>, i: I) -&gt; PResult&lt;OM, I, <span class="self">Self</span>::Output, <span class="self">Self</span>::Error&gt; {
<a href=#677 id=677 data-nosnippet>677</a> <span class="kw">let </span>(input, o1) = <span class="self">self
<a href=#678 id=678 data-nosnippet>678</a> </span>.f
<a href=#679 id=679 data-nosnippet>679</a> .process::&lt;OutputM&lt;Emit, OM::Error, OM::Incomplete&gt;&gt;(i)<span class="question-mark">?</span>;
<a href=#680 id=680 data-nosnippet>680</a>
<a href=#681 id=681 data-nosnippet>681</a> (<span class="self">self</span>.g)(o1).process::&lt;OM&gt;(input)
<a href=#682 id=682 data-nosnippet>682</a> }
<a href=#683 id=683 data-nosnippet>683</a>}
<a href=#684 id=684 data-nosnippet>684</a>
<a href=#685 id=685 data-nosnippet>685</a><span class="doccomment">/// Implementation of `Parser::and_then`
<a href=#686 id=686 data-nosnippet>686</a></span><span class="kw">pub struct </span>AndThen&lt;F, G&gt; {
<a href=#687 id=687 data-nosnippet>687</a> f: F,
<a href=#688 id=688 data-nosnippet>688</a> g: G,
<a href=#689 id=689 data-nosnippet>689</a>}
<a href=#690 id=690 data-nosnippet>690</a>
<a href=#691 id=691 data-nosnippet>691</a><span class="kw">impl</span>&lt;I, F: Parser&lt;I&gt;, G: Parser&lt;&lt;F <span class="kw">as </span>Parser&lt;I&gt;&gt;::Output, Error = &lt;F <span class="kw">as </span>Parser&lt;I&gt;&gt;::Error&gt;&gt;
<a href=#692 id=692 data-nosnippet>692</a> Parser&lt;I&gt; <span class="kw">for </span>AndThen&lt;F, G&gt;
<a href=#693 id=693 data-nosnippet>693</a>{
<a href=#694 id=694 data-nosnippet>694</a> <span class="kw">type </span>Output = &lt;G <span class="kw">as </span>Parser&lt;&lt;F <span class="kw">as </span>Parser&lt;I&gt;&gt;::Output&gt;&gt;::Output;
<a href=#695 id=695 data-nosnippet>695</a> <span class="kw">type </span>Error = &lt;F <span class="kw">as </span>Parser&lt;I&gt;&gt;::Error;
<a href=#696 id=696 data-nosnippet>696</a>
<a href=#697 id=697 data-nosnippet>697</a> <span class="kw">fn </span>process&lt;OM: OutputMode&gt;(<span class="kw-2">&amp;mut </span><span class="self">self</span>, i: I) -&gt; PResult&lt;OM, I, <span class="self">Self</span>::Output, <span class="self">Self</span>::Error&gt; {
<a href=#698 id=698 data-nosnippet>698</a> <span class="kw">let </span>(input, o1) = <span class="self">self
<a href=#699 id=699 data-nosnippet>699</a> </span>.f
<a href=#700 id=700 data-nosnippet>700</a> .process::&lt;OutputM&lt;Emit, OM::Error, OM::Incomplete&gt;&gt;(i)<span class="question-mark">?</span>;
<a href=#701 id=701 data-nosnippet>701</a>
<a href=#702 id=702 data-nosnippet>702</a> <span class="kw">let </span>(<span class="kw">_</span>, o2) = <span class="self">self</span>.g.process::&lt;OM&gt;(o1)<span class="question-mark">?</span>;
<a href=#703 id=703 data-nosnippet>703</a> <span class="prelude-val">Ok</span>((input, o2))
<a href=#704 id=704 data-nosnippet>704</a> }
<a href=#705 id=705 data-nosnippet>705</a>}
<a href=#706 id=706 data-nosnippet>706</a>
<a href=#707 id=707 data-nosnippet>707</a><span class="doccomment">/// Implementation of `Parser::and`
<a href=#708 id=708 data-nosnippet>708</a></span><span class="kw">pub struct </span>And&lt;F, G&gt; {
<a href=#709 id=709 data-nosnippet>709</a> f: F,
<a href=#710 id=710 data-nosnippet>710</a> g: G,
<a href=#711 id=711 data-nosnippet>711</a>}
<a href=#712 id=712 data-nosnippet>712</a>
<a href=#713 id=713 data-nosnippet>713</a><span class="kw">impl</span>&lt;I, E: ParseError&lt;I&gt;, F: Parser&lt;I, Error = E&gt;, G: Parser&lt;I, Error = E&gt;&gt; Parser&lt;I&gt;
<a href=#714 id=714 data-nosnippet>714</a> <span class="kw">for </span>And&lt;F, G&gt;
<a href=#715 id=715 data-nosnippet>715</a>{
<a href=#716 id=716 data-nosnippet>716</a> <span class="kw">type </span>Output = (&lt;F <span class="kw">as </span>Parser&lt;I&gt;&gt;::Output, &lt;G <span class="kw">as </span>Parser&lt;I&gt;&gt;::Output);
<a href=#717 id=717 data-nosnippet>717</a> <span class="kw">type </span>Error = E;
<a href=#718 id=718 data-nosnippet>718</a>
<a href=#719 id=719 data-nosnippet>719</a> <span class="attr">#[inline(always)]
<a href=#720 id=720 data-nosnippet>720</a> </span><span class="kw">fn </span>process&lt;OM: OutputMode&gt;(<span class="kw-2">&amp;mut </span><span class="self">self</span>, i: I) -&gt; PResult&lt;OM, I, <span class="self">Self</span>::Output, <span class="self">Self</span>::Error&gt; {
<a href=#721 id=721 data-nosnippet>721</a> <span class="kw">let </span>(i, o1) = <span class="self">self</span>.f.process::&lt;OM&gt;(i)<span class="question-mark">?</span>;
<a href=#722 id=722 data-nosnippet>722</a> <span class="kw">let </span>(i, o2) = <span class="self">self</span>.g.process::&lt;OM&gt;(i)<span class="question-mark">?</span>;
<a href=#723 id=723 data-nosnippet>723</a>
<a href=#724 id=724 data-nosnippet>724</a> <span class="prelude-val">Ok</span>((i, OM::Output::combine(o1, o2, |o1, o2| (o1, o2))))
<a href=#725 id=725 data-nosnippet>725</a> }
<a href=#726 id=726 data-nosnippet>726</a>}
<a href=#727 id=727 data-nosnippet>727</a>
<a href=#728 id=728 data-nosnippet>728</a><span class="doccomment">/// Implementation of `Parser::or`
<a href=#729 id=729 data-nosnippet>729</a></span><span class="kw">pub struct </span>Or&lt;F, G&gt; {
<a href=#730 id=730 data-nosnippet>730</a> f: F,
<a href=#731 id=731 data-nosnippet>731</a> g: G,
<a href=#732 id=732 data-nosnippet>732</a>}
<a href=#733 id=733 data-nosnippet>733</a>
<a href=#734 id=734 data-nosnippet>734</a><span class="kw">impl</span>&lt;
<a href=#735 id=735 data-nosnippet>735</a> I: Clone,
<a href=#736 id=736 data-nosnippet>736</a> O,
<a href=#737 id=737 data-nosnippet>737</a> E: ParseError&lt;I&gt;,
<a href=#738 id=738 data-nosnippet>738</a> F: Parser&lt;I, Output = O, Error = E&gt;,
<a href=#739 id=739 data-nosnippet>739</a> G: Parser&lt;I, Output = O, Error = E&gt;,
<a href=#740 id=740 data-nosnippet>740</a> &gt; Parser&lt;I&gt; <span class="kw">for </span>Or&lt;F, G&gt;
<a href=#741 id=741 data-nosnippet>741</a>{
<a href=#742 id=742 data-nosnippet>742</a> <span class="kw">type </span>Output = &lt;F <span class="kw">as </span>Parser&lt;I&gt;&gt;::Output;
<a href=#743 id=743 data-nosnippet>743</a> <span class="kw">type </span>Error = &lt;F <span class="kw">as </span>Parser&lt;I&gt;&gt;::Error;
<a href=#744 id=744 data-nosnippet>744</a>
<a href=#745 id=745 data-nosnippet>745</a> <span class="kw">fn </span>process&lt;OM: OutputMode&gt;(<span class="kw-2">&amp;mut </span><span class="self">self</span>, i: I) -&gt; PResult&lt;OM, I, <span class="self">Self</span>::Output, <span class="self">Self</span>::Error&gt; {
<a href=#746 id=746 data-nosnippet>746</a> <span class="kw">match </span><span class="self">self</span>.f.process::&lt;OM&gt;(i.clone()) {
<a href=#747 id=747 data-nosnippet>747</a> <span class="prelude-val">Err</span>(Err::Error(e1)) =&gt; <span class="kw">match </span><span class="self">self</span>.g.process::&lt;OM&gt;(i) {
<a href=#748 id=748 data-nosnippet>748</a> <span class="prelude-val">Err</span>(Err::Error(e2)) =&gt; <span class="prelude-val">Err</span>(Err::Error(OM::Error::combine(e1, e2, |e1, e2| e1.or(e2)))),
<a href=#749 id=749 data-nosnippet>749</a> res =&gt; res,
<a href=#750 id=750 data-nosnippet>750</a> },
<a href=#751 id=751 data-nosnippet>751</a> res =&gt; res,
<a href=#752 id=752 data-nosnippet>752</a> }
<a href=#753 id=753 data-nosnippet>753</a> }
<a href=#754 id=754 data-nosnippet>754</a>}
<a href=#755 id=755 data-nosnippet>755</a>
<a href=#756 id=756 data-nosnippet>756</a><span class="doccomment">/// Implementation of `Parser::into`
<a href=#757 id=757 data-nosnippet>757</a></span><span class="kw">pub struct </span>Into&lt;F, O2, E2&gt; {
<a href=#758 id=758 data-nosnippet>758</a> f: F,
<a href=#759 id=759 data-nosnippet>759</a> phantom_out2: core::marker::PhantomData&lt;O2&gt;,
<a href=#760 id=760 data-nosnippet>760</a> phantom_err2: core::marker::PhantomData&lt;E2&gt;,
<a href=#761 id=761 data-nosnippet>761</a>}
<a href=#762 id=762 data-nosnippet>762</a>
<a href=#763 id=763 data-nosnippet>763</a><span class="kw">impl</span>&lt;
<a href=#764 id=764 data-nosnippet>764</a> I,
<a href=#765 id=765 data-nosnippet>765</a> O2: From&lt;&lt;F <span class="kw">as </span>Parser&lt;I&gt;&gt;::Output&gt;,
<a href=#766 id=766 data-nosnippet>766</a> E2: <span class="kw">crate</span>::error::ParseError&lt;I&gt; + From&lt;&lt;F <span class="kw">as </span>Parser&lt;I&gt;&gt;::Error&gt;,
<a href=#767 id=767 data-nosnippet>767</a> F: Parser&lt;I&gt;,
<a href=#768 id=768 data-nosnippet>768</a> &gt; Parser&lt;I&gt; <span class="kw">for </span>Into&lt;F, O2, E2&gt;
<a href=#769 id=769 data-nosnippet>769</a>{
<a href=#770 id=770 data-nosnippet>770</a> <span class="kw">type </span>Output = O2;
<a href=#771 id=771 data-nosnippet>771</a> <span class="kw">type </span>Error = E2;
<a href=#772 id=772 data-nosnippet>772</a>
<a href=#773 id=773 data-nosnippet>773</a> <span class="kw">fn </span>process&lt;OM: OutputMode&gt;(<span class="kw-2">&amp;mut </span><span class="self">self</span>, i: I) -&gt; PResult&lt;OM, I, <span class="self">Self</span>::Output, <span class="self">Self</span>::Error&gt; {
<a href=#774 id=774 data-nosnippet>774</a> <span class="kw">match </span><span class="self">self</span>.f.process::&lt;OM&gt;(i) {
<a href=#775 id=775 data-nosnippet>775</a> <span class="prelude-val">Ok</span>((i, o)) =&gt; <span class="prelude-val">Ok</span>((i, OM::Output::map(o, |o| o.into()))),
<a href=#776 id=776 data-nosnippet>776</a> <span class="prelude-val">Err</span>(Err::Error(e)) =&gt; <span class="prelude-val">Err</span>(Err::Error(OM::Error::map(e, |e| e.into()))),
<a href=#777 id=777 data-nosnippet>777</a> <span class="prelude-val">Err</span>(Err::Failure(e)) =&gt; <span class="prelude-val">Err</span>(Err::Failure(e.into())),
<a href=#778 id=778 data-nosnippet>778</a> <span class="prelude-val">Err</span>(Err::Incomplete(e)) =&gt; <span class="prelude-val">Err</span>(Err::Incomplete(e)),
<a href=#779 id=779 data-nosnippet>779</a> }
<a href=#780 id=780 data-nosnippet>780</a> }
<a href=#781 id=781 data-nosnippet>781</a>}
<a href=#782 id=782 data-nosnippet>782</a>
<a href=#783 id=783 data-nosnippet>783</a><span class="doccomment">/// Alternate between two Parser implementations with the same result type.
<a href=#784 id=784 data-nosnippet>784</a></span><span class="kw">pub</span>(<span class="kw">crate</span>) <span class="kw">enum </span>Either&lt;F, G&gt; {
<a href=#785 id=785 data-nosnippet>785</a> Left(F),
<a href=#786 id=786 data-nosnippet>786</a> Right(G),
<a href=#787 id=787 data-nosnippet>787</a>}
<a href=#788 id=788 data-nosnippet>788</a>
<a href=#789 id=789 data-nosnippet>789</a><span class="kw">impl</span>&lt;
<a href=#790 id=790 data-nosnippet>790</a> I,
<a href=#791 id=791 data-nosnippet>791</a> F: Parser&lt;I&gt;,
<a href=#792 id=792 data-nosnippet>792</a> G: Parser&lt;I, Output = &lt;F <span class="kw">as </span>Parser&lt;I&gt;&gt;::Output, Error = &lt;F <span class="kw">as </span>Parser&lt;I&gt;&gt;::Error&gt;,
<a href=#793 id=793 data-nosnippet>793</a> &gt; Parser&lt;I&gt; <span class="kw">for </span>Either&lt;F, G&gt;
<a href=#794 id=794 data-nosnippet>794</a>{
<a href=#795 id=795 data-nosnippet>795</a> <span class="kw">type </span>Output = &lt;F <span class="kw">as </span>Parser&lt;I&gt;&gt;::Output;
<a href=#796 id=796 data-nosnippet>796</a> <span class="kw">type </span>Error = &lt;F <span class="kw">as </span>Parser&lt;I&gt;&gt;::Error;
<a href=#797 id=797 data-nosnippet>797</a>
<a href=#798 id=798 data-nosnippet>798</a> <span class="attr">#[inline]
<a href=#799 id=799 data-nosnippet>799</a> </span><span class="kw">fn </span>process&lt;OM: OutputMode&gt;(<span class="kw-2">&amp;mut </span><span class="self">self</span>, i: I) -&gt; PResult&lt;OM, I, <span class="self">Self</span>::Output, <span class="self">Self</span>::Error&gt; {
<a href=#800 id=800 data-nosnippet>800</a> <span class="kw">match </span><span class="self">self </span>{
<a href=#801 id=801 data-nosnippet>801</a> Either::Left(f) =&gt; f.process::&lt;OM&gt;(i),
<a href=#802 id=802 data-nosnippet>802</a> Either::Right(g) =&gt; g.process::&lt;OM&gt;(i),
<a href=#803 id=803 data-nosnippet>803</a> }
<a href=#804 id=804 data-nosnippet>804</a> }
<a href=#805 id=805 data-nosnippet>805</a>}
<a href=#806 id=806 data-nosnippet>806</a>
<a href=#807 id=807 data-nosnippet>807</a><span class="attr">#[cfg(test)]
<a href=#808 id=808 data-nosnippet>808</a></span><span class="kw">mod </span>tests {
<a href=#809 id=809 data-nosnippet>809</a> <span class="kw">use super</span>::<span class="kw-2">*</span>;
<a href=#810 id=810 data-nosnippet>810</a> <span class="kw">use </span><span class="kw">crate</span>::error::ErrorKind;
<a href=#811 id=811 data-nosnippet>811</a>
<a href=#812 id=812 data-nosnippet>812</a> <span class="kw">use </span><span class="kw">crate</span>::bytes::streaming::{tag, take};
<a href=#813 id=813 data-nosnippet>813</a> <span class="kw">use </span><span class="kw">crate</span>::number::streaming::be_u16;
<a href=#814 id=814 data-nosnippet>814</a> <span class="kw">use </span><span class="kw">crate</span>::sequence::terminated;
<a href=#815 id=815 data-nosnippet>815</a>
<a href=#816 id=816 data-nosnippet>816</a> <span class="attr">#[doc(hidden)]
<a href=#817 id=817 data-nosnippet>817</a> #[macro_export]
<a href=#818 id=818 data-nosnippet>818</a> </span><span class="macro">macro_rules!</span> assert_size (
<a href=#819 id=819 data-nosnippet>819</a> (<span class="macro-nonterminal">$t</span>:ty, <span class="macro-nonterminal">$sz</span>:expr) =&gt; (
<a href=#820 id=820 data-nosnippet>820</a> <span class="macro">assert_eq!</span>(<span class="macro-nonterminal">$crate::lib::std::mem::size_of</span>::&lt;<span class="macro-nonterminal">$t</span>&gt;(), <span class="macro-nonterminal">$sz</span>);
<a href=#821 id=821 data-nosnippet>821</a> );
<a href=#822 id=822 data-nosnippet>822</a> );
<a href=#823 id=823 data-nosnippet>823</a>
<a href=#824 id=824 data-nosnippet>824</a> <span class="attr">#[test]
<a href=#825 id=825 data-nosnippet>825</a> #[cfg(target_pointer_width = <span class="string">"64"</span>)]
<a href=#826 id=826 data-nosnippet>826</a> </span><span class="kw">fn </span>size_test() {
<a href=#827 id=827 data-nosnippet>827</a> <span class="macro">assert_size!</span>(IResult&lt;<span class="kw-2">&amp;</span>[u8], <span class="kw-2">&amp;</span>[u8], (<span class="kw-2">&amp;</span>[u8], u32)&gt;, <span class="number">40</span>);
<a href=#828 id=828 data-nosnippet>828</a> <span class="comment">//FIXME: since rust 1.65, this is now 32 bytes, likely thanks to https://github.com/rust-lang/rust/pull/94075
<a href=#829 id=829 data-nosnippet>829</a> // deactivating that test for now because it'll have different values depending on the rust version
<a href=#830 id=830 data-nosnippet>830</a> // assert_size!(IResult&lt;&amp;str, &amp;str, u32&gt;, 40);
<a href=#831 id=831 data-nosnippet>831</a> </span><span class="macro">assert_size!</span>(Needed, <span class="number">8</span>);
<a href=#832 id=832 data-nosnippet>832</a> <span class="macro">assert_size!</span>(<span class="prelude-val">Err</span>&lt;u32&gt;, <span class="number">16</span>);
<a href=#833 id=833 data-nosnippet>833</a> <span class="macro">assert_size!</span>(ErrorKind, <span class="number">1</span>);
<a href=#834 id=834 data-nosnippet>834</a> }
<a href=#835 id=835 data-nosnippet>835</a>
<a href=#836 id=836 data-nosnippet>836</a> <span class="attr">#[test]
<a href=#837 id=837 data-nosnippet>837</a> </span><span class="kw">fn </span>err_map_test() {
<a href=#838 id=838 data-nosnippet>838</a> <span class="kw">let </span>e = Err::Error(<span class="number">1</span>);
<a href=#839 id=839 data-nosnippet>839</a> <span class="macro">assert_eq!</span>(e.map(|v| v + <span class="number">1</span>), Err::Error(<span class="number">2</span>));
<a href=#840 id=840 data-nosnippet>840</a> }
<a href=#841 id=841 data-nosnippet>841</a>
<a href=#842 id=842 data-nosnippet>842</a> <span class="attr">#[test]
<a href=#843 id=843 data-nosnippet>843</a> </span><span class="kw">fn </span>native_tuple_test() {
<a href=#844 id=844 data-nosnippet>844</a> <span class="kw">fn </span>tuple_3(i: <span class="kw-2">&amp;</span>[u8]) -&gt; IResult&lt;<span class="kw-2">&amp;</span>[u8], (u16, <span class="kw-2">&amp;</span>[u8])&gt; {
<a href=#845 id=845 data-nosnippet>845</a> terminated((be_u16, take(<span class="number">3u8</span>)), tag(<span class="string">"fg"</span>)).parse(i)
<a href=#846 id=846 data-nosnippet>846</a> }
<a href=#847 id=847 data-nosnippet>847</a>
<a href=#848 id=848 data-nosnippet>848</a> <span class="macro">assert_eq!</span>(
<a href=#849 id=849 data-nosnippet>849</a> tuple_3(<span class="kw-2">&amp;</span><span class="string">b"abcdefgh"</span>[..]),
<a href=#850 id=850 data-nosnippet>850</a> <span class="prelude-val">Ok</span>((<span class="kw-2">&amp;</span><span class="string">b"h"</span>[..], (<span class="number">0x6162u16</span>, <span class="kw-2">&amp;</span><span class="string">b"cde"</span>[..])))
<a href=#851 id=851 data-nosnippet>851</a> );
<a href=#852 id=852 data-nosnippet>852</a> <span class="macro">assert_eq!</span>(tuple_3(<span class="kw-2">&amp;</span><span class="string">b"abcd"</span>[..]), <span class="prelude-val">Err</span>(Err::Incomplete(Needed::new(<span class="number">1</span>))));
<a href=#853 id=853 data-nosnippet>853</a> <span class="macro">assert_eq!</span>(tuple_3(<span class="kw-2">&amp;</span><span class="string">b"abcde"</span>[..]), <span class="prelude-val">Err</span>(Err::Incomplete(Needed::new(<span class="number">2</span>))));
<a href=#854 id=854 data-nosnippet>854</a> <span class="macro">assert_eq!</span>(
<a href=#855 id=855 data-nosnippet>855</a> tuple_3(<span class="kw-2">&amp;</span><span class="string">b"abcdejk"</span>[..]),
<a href=#856 id=856 data-nosnippet>856</a> <span class="prelude-val">Err</span>(Err::Error(<span class="macro">error_position!</span>(<span class="kw-2">&amp;</span><span class="string">b"jk"</span>[..], ErrorKind::Tag)))
<a href=#857 id=857 data-nosnippet>857</a> );
<a href=#858 id=858 data-nosnippet>858</a> }
<a href=#859 id=859 data-nosnippet>859</a>}
</code></pre></div></section></main></body></html>
+461
View File
@@ -0,0 +1,461 @@
<!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 of the Rust file `/home/newkirk/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/nom-8.0.0/src/lib.rs`."><title>lib.rs - source</title><script>if(window.location.protocol!=="file:")document.head.insertAdjacentHTML("beforeend","SourceSerif4-Regular-6b053e98.ttf.woff2,FiraSans-Italic-81dc35de.woff2,FiraSans-Regular-0fe48ade.woff2,FiraSans-MediumItalic-ccf7e434.woff2,FiraSans-Medium-e1aa3f0a.woff2,SourceCodePro-Regular-8badfe75.ttf.woff2,SourceCodePro-Semibold-aa29a496.ttf.woff2".split(",").map(f=>`<link rel="preload" as="font" type="font/woff2"href="../../static.files/${f}">`).join(""))</script><link rel="stylesheet" href="../../static.files/normalize-9960930a.css"><link rel="stylesheet" href="../../static.files/rustdoc-ca0dd0c4.css"><meta name="rustdoc-vars" data-root-path="../../" data-static-root-path="../../static.files/" data-current-crate="nom" data-themes="" data-resource-suffix="" data-rustdoc-version="1.93.1 (01f6ddf75 2026-02-11) (Arch Linux rust 1:1.93.1-1)" data-channel="1.93.1" data-search-js="search-9e2438ea.js" data-stringdex-js="stringdex-a3946164.js" data-settings-js="settings-c38705f0.js" ><script src="../../static.files/storage-e2aeef58.js"></script><script defer src="../../static.files/src-script-813739b1.js"></script><script defer src="../../src-files.js"></script><script defer src="../../static.files/main-a410ff4d.js"></script><noscript><link rel="stylesheet" href="../../static.files/noscript-263c88ec.css"></noscript><link rel="alternate icon" type="image/png" href="../../static.files/favicon-32x32-eab170b8.png"><link rel="icon" type="image/svg+xml" href="../../static.files/favicon-044be391.svg"></head><body class="rustdoc src"><!--[if lte IE 11]><div class="warning">This old browser is unsupported and will most likely display funky things.</div><![endif]--><nav class="sidebar"><div class="src-sidebar-title"><h2>Files</h2></div></nav><div class="sidebar-resizer" title="Drag to resize sidebar"></div><main><section id="main-content" class="content"><div class="main-heading"><h1><div class="sub-heading">nom/</div>lib.rs</h1><rustdoc-toolbar></rustdoc-toolbar></div><div class="example-wrap digits-3"><pre class="rust"><code><a href=#1 id=1 data-nosnippet>1</a><span class="doccomment">//! # nom, eating data byte by byte
<a href=#2 id=2 data-nosnippet>2</a>//!
<a href=#3 id=3 data-nosnippet>3</a>//! nom is a parser combinator library with a focus on safe parsing,
<a href=#4 id=4 data-nosnippet>4</a>//! streaming patterns, and as much as possible zero copy.
<a href=#5 id=5 data-nosnippet>5</a>//!
<a href=#6 id=6 data-nosnippet>6</a>//! ## Example
<a href=#7 id=7 data-nosnippet>7</a>//!
<a href=#8 id=8 data-nosnippet>8</a>//! ```rust
<a href=#9 id=9 data-nosnippet>9</a>//! use nom::{
<a href=#10 id=10 data-nosnippet>10</a>//! IResult,
<a href=#11 id=11 data-nosnippet>11</a>//! Parser,
<a href=#12 id=12 data-nosnippet>12</a>//! bytes::complete::{tag, take_while_m_n},
<a href=#13 id=13 data-nosnippet>13</a>//! combinator::map_res
<a href=#14 id=14 data-nosnippet>14</a>//! };
<a href=#15 id=15 data-nosnippet>15</a>//!
<a href=#16 id=16 data-nosnippet>16</a>//! #[derive(Debug,PartialEq)]
<a href=#17 id=17 data-nosnippet>17</a>//! pub struct Color {
<a href=#18 id=18 data-nosnippet>18</a>//! pub red: u8,
<a href=#19 id=19 data-nosnippet>19</a>//! pub green: u8,
<a href=#20 id=20 data-nosnippet>20</a>//! pub blue: u8,
<a href=#21 id=21 data-nosnippet>21</a>//! }
<a href=#22 id=22 data-nosnippet>22</a>//!
<a href=#23 id=23 data-nosnippet>23</a>//! fn from_hex(input: &amp;str) -&gt; Result&lt;u8, std::num::ParseIntError&gt; {
<a href=#24 id=24 data-nosnippet>24</a>//! u8::from_str_radix(input, 16)
<a href=#25 id=25 data-nosnippet>25</a>//! }
<a href=#26 id=26 data-nosnippet>26</a>//!
<a href=#27 id=27 data-nosnippet>27</a>//! fn is_hex_digit(c: char) -&gt; bool {
<a href=#28 id=28 data-nosnippet>28</a>//! c.is_digit(16)
<a href=#29 id=29 data-nosnippet>29</a>//! }
<a href=#30 id=30 data-nosnippet>30</a>//!
<a href=#31 id=31 data-nosnippet>31</a>//! fn hex_primary(input: &amp;str) -&gt; IResult&lt;&amp;str, u8&gt; {
<a href=#32 id=32 data-nosnippet>32</a>//! map_res(
<a href=#33 id=33 data-nosnippet>33</a>//! take_while_m_n(2, 2, is_hex_digit),
<a href=#34 id=34 data-nosnippet>34</a>//! from_hex
<a href=#35 id=35 data-nosnippet>35</a>//! ).parse(input)
<a href=#36 id=36 data-nosnippet>36</a>//! }
<a href=#37 id=37 data-nosnippet>37</a>//!
<a href=#38 id=38 data-nosnippet>38</a>//! fn hex_color(input: &amp;str) -&gt; IResult&lt;&amp;str, Color&gt; {
<a href=#39 id=39 data-nosnippet>39</a>//! let (input, _) = tag("#")(input)?;
<a href=#40 id=40 data-nosnippet>40</a>//! let (input, (red, green, blue)) = (hex_primary, hex_primary, hex_primary).parse(input)?;
<a href=#41 id=41 data-nosnippet>41</a>//!
<a href=#42 id=42 data-nosnippet>42</a>//! Ok((input, Color { red, green, blue }))
<a href=#43 id=43 data-nosnippet>43</a>//! }
<a href=#44 id=44 data-nosnippet>44</a>//!
<a href=#45 id=45 data-nosnippet>45</a>//! fn main() {
<a href=#46 id=46 data-nosnippet>46</a>//! assert_eq!(hex_color("#2F14DF"), Ok(("", Color {
<a href=#47 id=47 data-nosnippet>47</a>//! red: 47,
<a href=#48 id=48 data-nosnippet>48</a>//! green: 20,
<a href=#49 id=49 data-nosnippet>49</a>//! blue: 223,
<a href=#50 id=50 data-nosnippet>50</a>//! })));
<a href=#51 id=51 data-nosnippet>51</a>//! }
<a href=#52 id=52 data-nosnippet>52</a>//! ```
<a href=#53 id=53 data-nosnippet>53</a>//!
<a href=#54 id=54 data-nosnippet>54</a>//! The code is available on [GitHub](https://github.com/rust-bakery/nom)
<a href=#55 id=55 data-nosnippet>55</a>//!
<a href=#56 id=56 data-nosnippet>56</a>//! There are a few [guides](https://github.com/rust-bakery/nom/tree/main/doc) with more details
<a href=#57 id=57 data-nosnippet>57</a>//! about [how to write parsers](https://github.com/rust-bakery/nom/blob/main/doc/making_a_new_parser_from_scratch.md),
<a href=#58 id=58 data-nosnippet>58</a>//! or the [error management system](https://github.com/rust-bakery/nom/blob/main/doc/error_management.md).
<a href=#59 id=59 data-nosnippet>59</a>//! You can also check out the [recipes] module that contains examples of common patterns.
<a href=#60 id=60 data-nosnippet>60</a>//!
<a href=#61 id=61 data-nosnippet>61</a>//! **Looking for a specific combinator? Read the
<a href=#62 id=62 data-nosnippet>62</a>//! ["choose a combinator" guide](https://github.com/rust-bakery/nom/blob/main/doc/choosing_a_combinator.md)**
<a href=#63 id=63 data-nosnippet>63</a>//!
<a href=#64 id=64 data-nosnippet>64</a>//! If you are upgrading to nom 5.0, please read the
<a href=#65 id=65 data-nosnippet>65</a>//! [migration document](https://github.com/rust-bakery/nom/blob/main/doc/upgrading_to_nom_5.md).
<a href=#66 id=66 data-nosnippet>66</a>//!
<a href=#67 id=67 data-nosnippet>67</a>//! ## Parser combinators
<a href=#68 id=68 data-nosnippet>68</a>//!
<a href=#69 id=69 data-nosnippet>69</a>//! Parser combinators are an approach to parsers that is very different from
<a href=#70 id=70 data-nosnippet>70</a>//! software like [lex](https://en.wikipedia.org/wiki/Lex_(software)) and
<a href=#71 id=71 data-nosnippet>71</a>//! [yacc](https://en.wikipedia.org/wiki/Yacc). Instead of writing the grammar
<a href=#72 id=72 data-nosnippet>72</a>//! in a separate syntax and generating the corresponding code, you use very small
<a href=#73 id=73 data-nosnippet>73</a>//! functions with very specific purposes, like "take 5 bytes", or "recognize the
<a href=#74 id=74 data-nosnippet>74</a>//! word 'HTTP'", and assemble them in meaningful patterns like "recognize
<a href=#75 id=75 data-nosnippet>75</a>//! 'HTTP', then a space, then a version".
<a href=#76 id=76 data-nosnippet>76</a>//! The resulting code is small, and looks like the grammar you would have
<a href=#77 id=77 data-nosnippet>77</a>//! written with other parser approaches.
<a href=#78 id=78 data-nosnippet>78</a>//!
<a href=#79 id=79 data-nosnippet>79</a>//! This gives us a few advantages:
<a href=#80 id=80 data-nosnippet>80</a>//!
<a href=#81 id=81 data-nosnippet>81</a>//! - The parsers are small and easy to write
<a href=#82 id=82 data-nosnippet>82</a>//! - The parsers components are easy to reuse (if they're general enough, please add them to nom!)
<a href=#83 id=83 data-nosnippet>83</a>//! - The parsers components are easy to test separately (unit tests and property-based tests)
<a href=#84 id=84 data-nosnippet>84</a>//! - The parser combination code looks close to the grammar you would have written
<a href=#85 id=85 data-nosnippet>85</a>//! - You can build partial parsers, specific to the data you need at the moment, and ignore the rest
<a href=#86 id=86 data-nosnippet>86</a>//!
<a href=#87 id=87 data-nosnippet>87</a>//! Here is an example of one such parser, to recognize text between parentheses:
<a href=#88 id=88 data-nosnippet>88</a>//!
<a href=#89 id=89 data-nosnippet>89</a>//! ```rust
<a href=#90 id=90 data-nosnippet>90</a>//! use nom::{
<a href=#91 id=91 data-nosnippet>91</a>//! IResult,
<a href=#92 id=92 data-nosnippet>92</a>//! Parser,
<a href=#93 id=93 data-nosnippet>93</a>//! sequence::delimited,
<a href=#94 id=94 data-nosnippet>94</a>//! // see the "streaming/complete" paragraph lower for an explanation of these submodules
<a href=#95 id=95 data-nosnippet>95</a>//! character::complete::char,
<a href=#96 id=96 data-nosnippet>96</a>//! bytes::complete::is_not
<a href=#97 id=97 data-nosnippet>97</a>//! };
<a href=#98 id=98 data-nosnippet>98</a>//!
<a href=#99 id=99 data-nosnippet>99</a>//! fn parens(input: &amp;str) -&gt; IResult&lt;&amp;str, &amp;str&gt; {
<a href=#100 id=100 data-nosnippet>100</a>//! delimited(char('('), is_not(")"), char(')')).parse(input)
<a href=#101 id=101 data-nosnippet>101</a>//! }
<a href=#102 id=102 data-nosnippet>102</a>//! ```
<a href=#103 id=103 data-nosnippet>103</a>//!
<a href=#104 id=104 data-nosnippet>104</a>//! It defines a function named `parens` which will recognize a sequence of the
<a href=#105 id=105 data-nosnippet>105</a>//! character `(`, the longest byte array not containing `)`, then the character
<a href=#106 id=106 data-nosnippet>106</a>//! `)`, and will return the byte array in the middle.
<a href=#107 id=107 data-nosnippet>107</a>//!
<a href=#108 id=108 data-nosnippet>108</a>//! Here is another parser, written without using nom's combinators this time:
<a href=#109 id=109 data-nosnippet>109</a>//!
<a href=#110 id=110 data-nosnippet>110</a>//! ```rust
<a href=#111 id=111 data-nosnippet>111</a>//! use nom::{IResult, Err, Needed};
<a href=#112 id=112 data-nosnippet>112</a>//!
<a href=#113 id=113 data-nosnippet>113</a>//! # fn main() {
<a href=#114 id=114 data-nosnippet>114</a>//! fn take4(i: &amp;[u8]) -&gt; IResult&lt;&amp;[u8], &amp;[u8]&gt;{
<a href=#115 id=115 data-nosnippet>115</a>//! if i.len() &lt; 4 {
<a href=#116 id=116 data-nosnippet>116</a>//! Err(Err::Incomplete(Needed::new(4)))
<a href=#117 id=117 data-nosnippet>117</a>//! } else {
<a href=#118 id=118 data-nosnippet>118</a>//! Ok((&amp;i[4..], &amp;i[0..4]))
<a href=#119 id=119 data-nosnippet>119</a>//! }
<a href=#120 id=120 data-nosnippet>120</a>//! }
<a href=#121 id=121 data-nosnippet>121</a>//! # }
<a href=#122 id=122 data-nosnippet>122</a>//! ```
<a href=#123 id=123 data-nosnippet>123</a>//!
<a href=#124 id=124 data-nosnippet>124</a>//! This function takes a byte array as input, and tries to consume 4 bytes.
<a href=#125 id=125 data-nosnippet>125</a>//! Writing all the parsers manually, like this, is dangerous, despite Rust's
<a href=#126 id=126 data-nosnippet>126</a>//! safety features. There are still a lot of mistakes one can make. That's why
<a href=#127 id=127 data-nosnippet>127</a>//! nom provides a list of functions to help in developing parsers.
<a href=#128 id=128 data-nosnippet>128</a>//!
<a href=#129 id=129 data-nosnippet>129</a>//! With functions, you would write it like this:
<a href=#130 id=130 data-nosnippet>130</a>//!
<a href=#131 id=131 data-nosnippet>131</a>//! ```rust
<a href=#132 id=132 data-nosnippet>132</a>//! use nom::{IResult, bytes::streaming::take};
<a href=#133 id=133 data-nosnippet>133</a>//! fn take4(input: &amp;str) -&gt; IResult&lt;&amp;str, &amp;str&gt; {
<a href=#134 id=134 data-nosnippet>134</a>//! take(4u8)(input)
<a href=#135 id=135 data-nosnippet>135</a>//! }
<a href=#136 id=136 data-nosnippet>136</a>//! ```
<a href=#137 id=137 data-nosnippet>137</a>//!
<a href=#138 id=138 data-nosnippet>138</a>//! A parser in nom is a function which, for an input type `I`, an output type `O`
<a href=#139 id=139 data-nosnippet>139</a>//! and an optional error type `E`, will have the following signature:
<a href=#140 id=140 data-nosnippet>140</a>//!
<a href=#141 id=141 data-nosnippet>141</a>//! ```rust,compile_fail
<a href=#142 id=142 data-nosnippet>142</a>//! fn parser(input: I) -&gt; IResult&lt;I, O, E&gt;;
<a href=#143 id=143 data-nosnippet>143</a>//! ```
<a href=#144 id=144 data-nosnippet>144</a>//!
<a href=#145 id=145 data-nosnippet>145</a>//! Or like this, if you don't want to specify a custom error type (it will be `(I, ErrorKind)` by default):
<a href=#146 id=146 data-nosnippet>146</a>//!
<a href=#147 id=147 data-nosnippet>147</a>//! ```rust,compile_fail
<a href=#148 id=148 data-nosnippet>148</a>//! fn parser(input: I) -&gt; IResult&lt;I, O&gt;;
<a href=#149 id=149 data-nosnippet>149</a>//! ```
<a href=#150 id=150 data-nosnippet>150</a>//!
<a href=#151 id=151 data-nosnippet>151</a>//! `IResult` is an alias for the `Result` type:
<a href=#152 id=152 data-nosnippet>152</a>//!
<a href=#153 id=153 data-nosnippet>153</a>//! ```rust
<a href=#154 id=154 data-nosnippet>154</a>//! use nom::{Needed, error::Error};
<a href=#155 id=155 data-nosnippet>155</a>//!
<a href=#156 id=156 data-nosnippet>156</a>//! type IResult&lt;I, O, E = Error&lt;I&gt;&gt; = Result&lt;(I, O), Err&lt;E&gt;&gt;;
<a href=#157 id=157 data-nosnippet>157</a>//!
<a href=#158 id=158 data-nosnippet>158</a>//! enum Err&lt;E&gt; {
<a href=#159 id=159 data-nosnippet>159</a>//! Incomplete(Needed),
<a href=#160 id=160 data-nosnippet>160</a>//! Error(E),
<a href=#161 id=161 data-nosnippet>161</a>//! Failure(E),
<a href=#162 id=162 data-nosnippet>162</a>//! }
<a href=#163 id=163 data-nosnippet>163</a>//! ```
<a href=#164 id=164 data-nosnippet>164</a>//!
<a href=#165 id=165 data-nosnippet>165</a>//! It can have the following values:
<a href=#166 id=166 data-nosnippet>166</a>//!
<a href=#167 id=167 data-nosnippet>167</a>//! - A correct result `Ok((I,O))` with the first element being the remaining of the input (not parsed yet), and the second the output value;
<a href=#168 id=168 data-nosnippet>168</a>//! - An error `Err(Err::Error(c))` with `c` an error that can be built from the input position and a parser specific error
<a href=#169 id=169 data-nosnippet>169</a>//! - An error `Err(Err::Incomplete(Needed))` indicating that more input is necessary. `Needed` can indicate how much data is needed
<a href=#170 id=170 data-nosnippet>170</a>//! - An error `Err(Err::Failure(c))`. It works like the `Error` case, except it indicates an unrecoverable error: We cannot backtrack and test another parser
<a href=#171 id=171 data-nosnippet>171</a>//!
<a href=#172 id=172 data-nosnippet>172</a>//! Please refer to the ["choose a combinator" guide](https://github.com/rust-bakery/nom/blob/main/doc/choosing_a_combinator.md) for an exhaustive list of parsers.
<a href=#173 id=173 data-nosnippet>173</a>//! See also the rest of the documentation [here](https://github.com/rust-bakery/nom/tree/main/doc).
<a href=#174 id=174 data-nosnippet>174</a>//!
<a href=#175 id=175 data-nosnippet>175</a>//! ## Making new parsers with function combinators
<a href=#176 id=176 data-nosnippet>176</a>//!
<a href=#177 id=177 data-nosnippet>177</a>//! nom is based on functions that generate parsers, with a signature like
<a href=#178 id=178 data-nosnippet>178</a>//! this: `(arguments) -&gt; impl Fn(Input) -&gt; IResult&lt;Input, Output, Error&gt;`.
<a href=#179 id=179 data-nosnippet>179</a>//! The arguments of a combinator can be direct values (like `take` which uses
<a href=#180 id=180 data-nosnippet>180</a>//! a number of bytes or character as argument) or even other parsers (like
<a href=#181 id=181 data-nosnippet>181</a>//! `delimited` which takes as argument 3 parsers, and returns the result of
<a href=#182 id=182 data-nosnippet>182</a>//! the second one if all are successful).
<a href=#183 id=183 data-nosnippet>183</a>//!
<a href=#184 id=184 data-nosnippet>184</a>//! Here are some examples:
<a href=#185 id=185 data-nosnippet>185</a>//!
<a href=#186 id=186 data-nosnippet>186</a>//! ```rust
<a href=#187 id=187 data-nosnippet>187</a>//! use nom::IResult;
<a href=#188 id=188 data-nosnippet>188</a>//! use nom::bytes::complete::{tag, take};
<a href=#189 id=189 data-nosnippet>189</a>//! fn abcd_parser(i: &amp;str) -&gt; IResult&lt;&amp;str, &amp;str&gt; {
<a href=#190 id=190 data-nosnippet>190</a>//! tag("abcd")(i) // will consume bytes if the input begins with "abcd"
<a href=#191 id=191 data-nosnippet>191</a>//! }
<a href=#192 id=192 data-nosnippet>192</a>//!
<a href=#193 id=193 data-nosnippet>193</a>//! fn take_10(i: &amp;[u8]) -&gt; IResult&lt;&amp;[u8], &amp;[u8]&gt; {
<a href=#194 id=194 data-nosnippet>194</a>//! take(10u8)(i) // will consume and return 10 bytes of input
<a href=#195 id=195 data-nosnippet>195</a>//! }
<a href=#196 id=196 data-nosnippet>196</a>//! ```
<a href=#197 id=197 data-nosnippet>197</a>//!
<a href=#198 id=198 data-nosnippet>198</a>//! ## Combining parsers
<a href=#199 id=199 data-nosnippet>199</a>//!
<a href=#200 id=200 data-nosnippet>200</a>//! There are higher level patterns, like the **`alt`** combinator, which
<a href=#201 id=201 data-nosnippet>201</a>//! provides a choice between multiple parsers. If one branch fails, it tries
<a href=#202 id=202 data-nosnippet>202</a>//! the next, and returns the result of the first parser that succeeds:
<a href=#203 id=203 data-nosnippet>203</a>//!
<a href=#204 id=204 data-nosnippet>204</a>//! ```rust
<a href=#205 id=205 data-nosnippet>205</a>//! use nom::{IResult, Parser};
<a href=#206 id=206 data-nosnippet>206</a>//! use nom::branch::alt;
<a href=#207 id=207 data-nosnippet>207</a>//! use nom::bytes::complete::tag;
<a href=#208 id=208 data-nosnippet>208</a>//!
<a href=#209 id=209 data-nosnippet>209</a>//! let mut alt_tags = alt((tag("abcd"), tag("efgh")));
<a href=#210 id=210 data-nosnippet>210</a>//!
<a href=#211 id=211 data-nosnippet>211</a>//! assert_eq!(alt_tags.parse(&amp;b"abcdxxx"[..]), Ok((&amp;b"xxx"[..], &amp;b"abcd"[..])));
<a href=#212 id=212 data-nosnippet>212</a>//! assert_eq!(alt_tags.parse(&amp;b"efghxxx"[..]), Ok((&amp;b"xxx"[..], &amp;b"efgh"[..])));
<a href=#213 id=213 data-nosnippet>213</a>//! assert_eq!(alt_tags.parse(&amp;b"ijklxxx"[..]), Err(nom::Err::Error((&amp;b"ijklxxx"[..], nom::error::ErrorKind::Tag))));
<a href=#214 id=214 data-nosnippet>214</a>//! ```
<a href=#215 id=215 data-nosnippet>215</a>//!
<a href=#216 id=216 data-nosnippet>216</a>//! The **`opt`** combinator makes a parser optional. If the child parser returns
<a href=#217 id=217 data-nosnippet>217</a>//! an error, **`opt`** will still succeed and return None:
<a href=#218 id=218 data-nosnippet>218</a>//!
<a href=#219 id=219 data-nosnippet>219</a>//! ```rust
<a href=#220 id=220 data-nosnippet>220</a>//! use nom::{IResult, Parser, combinator::opt, bytes::complete::tag};
<a href=#221 id=221 data-nosnippet>221</a>//! fn abcd_opt(i: &amp;[u8]) -&gt; IResult&lt;&amp;[u8], Option&lt;&amp;[u8]&gt;&gt; {
<a href=#222 id=222 data-nosnippet>222</a>//! opt(tag("abcd")).parse(i)
<a href=#223 id=223 data-nosnippet>223</a>//! }
<a href=#224 id=224 data-nosnippet>224</a>//!
<a href=#225 id=225 data-nosnippet>225</a>//! assert_eq!(abcd_opt(&amp;b"abcdxxx"[..]), Ok((&amp;b"xxx"[..], Some(&amp;b"abcd"[..]))));
<a href=#226 id=226 data-nosnippet>226</a>//! assert_eq!(abcd_opt(&amp;b"efghxxx"[..]), Ok((&amp;b"efghxxx"[..], None)));
<a href=#227 id=227 data-nosnippet>227</a>//! ```
<a href=#228 id=228 data-nosnippet>228</a>//!
<a href=#229 id=229 data-nosnippet>229</a>//! **`many0`** applies a parser 0 or more times, and returns a vector of the aggregated results:
<a href=#230 id=230 data-nosnippet>230</a>//!
<a href=#231 id=231 data-nosnippet>231</a>//! ```rust
<a href=#232 id=232 data-nosnippet>232</a>//! # #[cfg(feature = "alloc")]
<a href=#233 id=233 data-nosnippet>233</a>//! # fn main() {
<a href=#234 id=234 data-nosnippet>234</a>//! use nom::{IResult, Parser, multi::many0, bytes::complete::tag};
<a href=#235 id=235 data-nosnippet>235</a>//! use std::str;
<a href=#236 id=236 data-nosnippet>236</a>//!
<a href=#237 id=237 data-nosnippet>237</a>//! fn multi(i: &amp;str) -&gt; IResult&lt;&amp;str, Vec&lt;&amp;str&gt;&gt; {
<a href=#238 id=238 data-nosnippet>238</a>//! many0(tag("abcd")).parse(i)
<a href=#239 id=239 data-nosnippet>239</a>//! }
<a href=#240 id=240 data-nosnippet>240</a>//!
<a href=#241 id=241 data-nosnippet>241</a>//! let a = "abcdef";
<a href=#242 id=242 data-nosnippet>242</a>//! let b = "abcdabcdef";
<a href=#243 id=243 data-nosnippet>243</a>//! let c = "azerty";
<a href=#244 id=244 data-nosnippet>244</a>//! assert_eq!(multi(a), Ok(("ef", vec!["abcd"])));
<a href=#245 id=245 data-nosnippet>245</a>//! assert_eq!(multi(b), Ok(("ef", vec!["abcd", "abcd"])));
<a href=#246 id=246 data-nosnippet>246</a>//! assert_eq!(multi(c), Ok(("azerty", Vec::new())));
<a href=#247 id=247 data-nosnippet>247</a>//! # }
<a href=#248 id=248 data-nosnippet>248</a>//! # #[cfg(not(feature = "alloc"))]
<a href=#249 id=249 data-nosnippet>249</a>//! # fn main() {}
<a href=#250 id=250 data-nosnippet>250</a>//! ```
<a href=#251 id=251 data-nosnippet>251</a>//!
<a href=#252 id=252 data-nosnippet>252</a>//! Here are some basic combinators available:
<a href=#253 id=253 data-nosnippet>253</a>//!
<a href=#254 id=254 data-nosnippet>254</a>//! - **`opt`**: Will make the parser optional (if it returns the `O` type, the new parser returns `Option&lt;O&gt;`)
<a href=#255 id=255 data-nosnippet>255</a>//! - **`many0`**: Will apply the parser 0 or more times (if it returns the `O` type, the new parser returns `Vec&lt;O&gt;`)
<a href=#256 id=256 data-nosnippet>256</a>//! - **`many1`**: Will apply the parser 1 or more times
<a href=#257 id=257 data-nosnippet>257</a>//!
<a href=#258 id=258 data-nosnippet>258</a>//! There are more complex (and more useful) parsers like tuples, which are
<a href=#259 id=259 data-nosnippet>259</a>//! used to apply a series of parsers then assemble their results.
<a href=#260 id=260 data-nosnippet>260</a>//!
<a href=#261 id=261 data-nosnippet>261</a>//! Example with a tuple of parsers:
<a href=#262 id=262 data-nosnippet>262</a>//!
<a href=#263 id=263 data-nosnippet>263</a>//! ```rust
<a href=#264 id=264 data-nosnippet>264</a>//! # fn main() {
<a href=#265 id=265 data-nosnippet>265</a>//! use nom::{
<a href=#266 id=266 data-nosnippet>266</a>//! error::ErrorKind,
<a href=#267 id=267 data-nosnippet>267</a>//! Needed,
<a href=#268 id=268 data-nosnippet>268</a>//! Parser,
<a href=#269 id=269 data-nosnippet>269</a>//! number::streaming::be_u16,
<a href=#270 id=270 data-nosnippet>270</a>//! bytes::streaming::{tag, take}};
<a href=#271 id=271 data-nosnippet>271</a>//!
<a href=#272 id=272 data-nosnippet>272</a>//! let mut tpl = (be_u16, take(3u8), tag("fg"));
<a href=#273 id=273 data-nosnippet>273</a>//!
<a href=#274 id=274 data-nosnippet>274</a>//! assert_eq!(
<a href=#275 id=275 data-nosnippet>275</a>//! tpl.parse(&amp;b"abcdefgh"[..]),
<a href=#276 id=276 data-nosnippet>276</a>//! Ok((
<a href=#277 id=277 data-nosnippet>277</a>//! &amp;b"h"[..],
<a href=#278 id=278 data-nosnippet>278</a>//! (0x6162u16, &amp;b"cde"[..], &amp;b"fg"[..])
<a href=#279 id=279 data-nosnippet>279</a>//! ))
<a href=#280 id=280 data-nosnippet>280</a>//! );
<a href=#281 id=281 data-nosnippet>281</a>//! assert_eq!(tpl.parse(&amp;b"abcde"[..]), Err(nom::Err::Incomplete(Needed::new(2))));
<a href=#282 id=282 data-nosnippet>282</a>//! let input = &amp;b"abcdejk"[..];
<a href=#283 id=283 data-nosnippet>283</a>//! assert_eq!(tpl.parse(input), Err(nom::Err::Error((&amp;input[5..], ErrorKind::Tag))));
<a href=#284 id=284 data-nosnippet>284</a>//! # }
<a href=#285 id=285 data-nosnippet>285</a>//! ```
<a href=#286 id=286 data-nosnippet>286</a>//!
<a href=#287 id=287 data-nosnippet>287</a>//! But you can also use a sequence of combinators written in imperative style,
<a href=#288 id=288 data-nosnippet>288</a>//! thanks to the `?` operator:
<a href=#289 id=289 data-nosnippet>289</a>//!
<a href=#290 id=290 data-nosnippet>290</a>//! ```rust
<a href=#291 id=291 data-nosnippet>291</a>//! # fn main() {
<a href=#292 id=292 data-nosnippet>292</a>//! use nom::{IResult, bytes::complete::tag};
<a href=#293 id=293 data-nosnippet>293</a>//!
<a href=#294 id=294 data-nosnippet>294</a>//! #[derive(Debug, PartialEq)]
<a href=#295 id=295 data-nosnippet>295</a>//! struct A {
<a href=#296 id=296 data-nosnippet>296</a>//! a: u8,
<a href=#297 id=297 data-nosnippet>297</a>//! b: u8
<a href=#298 id=298 data-nosnippet>298</a>//! }
<a href=#299 id=299 data-nosnippet>299</a>//!
<a href=#300 id=300 data-nosnippet>300</a>//! fn ret_int1(i:&amp;[u8]) -&gt; IResult&lt;&amp;[u8], u8&gt; { Ok((i,1)) }
<a href=#301 id=301 data-nosnippet>301</a>//! fn ret_int2(i:&amp;[u8]) -&gt; IResult&lt;&amp;[u8], u8&gt; { Ok((i,2)) }
<a href=#302 id=302 data-nosnippet>302</a>//!
<a href=#303 id=303 data-nosnippet>303</a>//! fn f(i: &amp;[u8]) -&gt; IResult&lt;&amp;[u8], A&gt; {
<a href=#304 id=304 data-nosnippet>304</a>//! // if successful, the parser returns `Ok((remaining_input, output_value))` that we can destructure
<a href=#305 id=305 data-nosnippet>305</a>//! let (i, _) = tag("abcd")(i)?;
<a href=#306 id=306 data-nosnippet>306</a>//! let (i, a) = ret_int1(i)?;
<a href=#307 id=307 data-nosnippet>307</a>//! let (i, _) = tag("efgh")(i)?;
<a href=#308 id=308 data-nosnippet>308</a>//! let (i, b) = ret_int2(i)?;
<a href=#309 id=309 data-nosnippet>309</a>//!
<a href=#310 id=310 data-nosnippet>310</a>//! Ok((i, A { a, b }))
<a href=#311 id=311 data-nosnippet>311</a>//! }
<a href=#312 id=312 data-nosnippet>312</a>//!
<a href=#313 id=313 data-nosnippet>313</a>//! let r = f(b"abcdefghX");
<a href=#314 id=314 data-nosnippet>314</a>//! assert_eq!(r, Ok((&amp;b"X"[..], A{a: 1, b: 2})));
<a href=#315 id=315 data-nosnippet>315</a>//! # }
<a href=#316 id=316 data-nosnippet>316</a>//! ```
<a href=#317 id=317 data-nosnippet>317</a>//!
<a href=#318 id=318 data-nosnippet>318</a>//! ## Streaming / Complete
<a href=#319 id=319 data-nosnippet>319</a>//!
<a href=#320 id=320 data-nosnippet>320</a>//! Some of nom's modules have `streaming` or `complete` submodules. They hold
<a href=#321 id=321 data-nosnippet>321</a>//! different variants of the same combinators.
<a href=#322 id=322 data-nosnippet>322</a>//!
<a href=#323 id=323 data-nosnippet>323</a>//! A streaming parser assumes that we might not have all of the input data.
<a href=#324 id=324 data-nosnippet>324</a>//! This can happen with some network protocol or large file parsers, where the
<a href=#325 id=325 data-nosnippet>325</a>//! input buffer can be full and need to be resized or refilled.
<a href=#326 id=326 data-nosnippet>326</a>//!
<a href=#327 id=327 data-nosnippet>327</a>//! A complete parser assumes that we already have all of the input data.
<a href=#328 id=328 data-nosnippet>328</a>//! This will be the common case with small files that can be read entirely to
<a href=#329 id=329 data-nosnippet>329</a>//! memory.
<a href=#330 id=330 data-nosnippet>330</a>//!
<a href=#331 id=331 data-nosnippet>331</a>//! Here is how it works in practice:
<a href=#332 id=332 data-nosnippet>332</a>//!
<a href=#333 id=333 data-nosnippet>333</a>//! ```rust
<a href=#334 id=334 data-nosnippet>334</a>//! use nom::{IResult, Err, Needed, error::{Error, ErrorKind}, bytes, character};
<a href=#335 id=335 data-nosnippet>335</a>//!
<a href=#336 id=336 data-nosnippet>336</a>//! fn take_streaming(i: &amp;[u8]) -&gt; IResult&lt;&amp;[u8], &amp;[u8]&gt; {
<a href=#337 id=337 data-nosnippet>337</a>//! bytes::streaming::take(4u8)(i)
<a href=#338 id=338 data-nosnippet>338</a>//! }
<a href=#339 id=339 data-nosnippet>339</a>//!
<a href=#340 id=340 data-nosnippet>340</a>//! fn take_complete(i: &amp;[u8]) -&gt; IResult&lt;&amp;[u8], &amp;[u8]&gt; {
<a href=#341 id=341 data-nosnippet>341</a>//! bytes::complete::take(4u8)(i)
<a href=#342 id=342 data-nosnippet>342</a>//! }
<a href=#343 id=343 data-nosnippet>343</a>//!
<a href=#344 id=344 data-nosnippet>344</a>//! // both parsers will take 4 bytes as expected
<a href=#345 id=345 data-nosnippet>345</a>//! assert_eq!(take_streaming(&amp;b"abcde"[..]), Ok((&amp;b"e"[..], &amp;b"abcd"[..])));
<a href=#346 id=346 data-nosnippet>346</a>//! assert_eq!(take_complete(&amp;b"abcde"[..]), Ok((&amp;b"e"[..], &amp;b"abcd"[..])));
<a href=#347 id=347 data-nosnippet>347</a>//!
<a href=#348 id=348 data-nosnippet>348</a>//! // if the input is smaller than 4 bytes, the streaming parser
<a href=#349 id=349 data-nosnippet>349</a>//! // will return `Incomplete` to indicate that we need more data
<a href=#350 id=350 data-nosnippet>350</a>//! assert_eq!(take_streaming(&amp;b"abc"[..]), Err(Err::Incomplete(Needed::new(1))));
<a href=#351 id=351 data-nosnippet>351</a>//!
<a href=#352 id=352 data-nosnippet>352</a>//! // but the complete parser will return an error
<a href=#353 id=353 data-nosnippet>353</a>//! assert_eq!(take_complete(&amp;b"abc"[..]), Err(Err::Error(Error::new(&amp;b"abc"[..], ErrorKind::Eof))));
<a href=#354 id=354 data-nosnippet>354</a>//!
<a href=#355 id=355 data-nosnippet>355</a>//! // the alpha0 function recognizes 0 or more alphabetic characters
<a href=#356 id=356 data-nosnippet>356</a>//! fn alpha0_streaming(i: &amp;str) -&gt; IResult&lt;&amp;str, &amp;str&gt; {
<a href=#357 id=357 data-nosnippet>357</a>//! character::streaming::alpha0(i)
<a href=#358 id=358 data-nosnippet>358</a>//! }
<a href=#359 id=359 data-nosnippet>359</a>//!
<a href=#360 id=360 data-nosnippet>360</a>//! fn alpha0_complete(i: &amp;str) -&gt; IResult&lt;&amp;str, &amp;str&gt; {
<a href=#361 id=361 data-nosnippet>361</a>//! character::complete::alpha0(i)
<a href=#362 id=362 data-nosnippet>362</a>//! }
<a href=#363 id=363 data-nosnippet>363</a>//!
<a href=#364 id=364 data-nosnippet>364</a>//! // if there's a clear limit to the recognized characters, both parsers work the same way
<a href=#365 id=365 data-nosnippet>365</a>//! assert_eq!(alpha0_streaming("abcd;"), Ok((";", "abcd")));
<a href=#366 id=366 data-nosnippet>366</a>//! assert_eq!(alpha0_complete("abcd;"), Ok((";", "abcd")));
<a href=#367 id=367 data-nosnippet>367</a>//!
<a href=#368 id=368 data-nosnippet>368</a>//! // but when there's no limit, the streaming version returns `Incomplete`, because it cannot
<a href=#369 id=369 data-nosnippet>369</a>//! // know if more input data should be recognized. The whole input could be "abcd;", or
<a href=#370 id=370 data-nosnippet>370</a>//! // "abcde;"
<a href=#371 id=371 data-nosnippet>371</a>//! assert_eq!(alpha0_streaming("abcd"), Err(Err::Incomplete(Needed::new(1))));
<a href=#372 id=372 data-nosnippet>372</a>//!
<a href=#373 id=373 data-nosnippet>373</a>//! // while the complete version knows that all of the data is there
<a href=#374 id=374 data-nosnippet>374</a>//! assert_eq!(alpha0_complete("abcd"), Ok(("", "abcd")));
<a href=#375 id=375 data-nosnippet>375</a>//! ```
<a href=#376 id=376 data-nosnippet>376</a>//! **Going further:** Read the [guides](https://github.com/rust-bakery/nom/tree/main/doc),
<a href=#377 id=377 data-nosnippet>377</a>//! check out the [recipes]!
<a href=#378 id=378 data-nosnippet>378</a></span><span class="attr">#![cfg_attr(not(feature = <span class="string">"std"</span>), no_std)]
<a href=#379 id=379 data-nosnippet>379</a>#![cfg_attr(feature = <span class="string">"docsrs"</span>, feature(doc_cfg))]
<a href=#380 id=380 data-nosnippet>380</a>#![allow(clippy::doc_markdown)]
<a href=#381 id=381 data-nosnippet>381</a>#![deny(missing_docs)]
<a href=#382 id=382 data-nosnippet>382</a>#[cfg(feature = <span class="string">"alloc"</span>)]
<a href=#383 id=383 data-nosnippet>383</a>#[macro_use]
<a href=#384 id=384 data-nosnippet>384</a></span><span class="kw">extern crate </span>alloc;
<a href=#385 id=385 data-nosnippet>385</a><span class="attr">#[cfg(doctest)]
<a href=#386 id=386 data-nosnippet>386</a></span><span class="kw">extern crate </span>doc_comment;
<a href=#387 id=387 data-nosnippet>387</a>
<a href=#388 id=388 data-nosnippet>388</a><span class="attr">#[cfg(doctest)]
<a href=#389 id=389 data-nosnippet>389</a></span><span class="macro">doc_comment::doctest!</span>(<span class="string">"../README.md"</span>);
<a href=#390 id=390 data-nosnippet>390</a>
<a href=#391 id=391 data-nosnippet>391</a><span class="doccomment">/// Lib module to re-export everything needed from `std` or `core`/`alloc`. This is how `serde` does
<a href=#392 id=392 data-nosnippet>392</a>/// it, albeit there it is not public.
<a href=#393 id=393 data-nosnippet>393</a></span><span class="kw">pub mod </span>lib {
<a href=#394 id=394 data-nosnippet>394</a> <span class="doccomment">/// `std` facade allowing `std`/`core` to be interchangeable. Reexports `alloc` crate optionally,
<a href=#395 id=395 data-nosnippet>395</a> /// as well as `core` or `std`
<a href=#396 id=396 data-nosnippet>396</a> </span><span class="attr">#[cfg(not(feature = <span class="string">"std"</span>))]
<a href=#397 id=397 data-nosnippet>397</a> </span><span class="doccomment">/// internal std exports for no_std compatibility
<a href=#398 id=398 data-nosnippet>398</a> </span><span class="kw">pub mod </span>std {
<a href=#399 id=399 data-nosnippet>399</a> <span class="attr">#[doc(hidden)]
<a href=#400 id=400 data-nosnippet>400</a> #[cfg(not(feature = <span class="string">"alloc"</span>))]
<a href=#401 id=401 data-nosnippet>401</a> </span><span class="kw">pub use </span>core::borrow;
<a href=#402 id=402 data-nosnippet>402</a>
<a href=#403 id=403 data-nosnippet>403</a> <span class="attr">#[cfg(feature = <span class="string">"alloc"</span>)]
<a href=#404 id=404 data-nosnippet>404</a> #[doc(hidden)]
<a href=#405 id=405 data-nosnippet>405</a> </span><span class="kw">pub use </span>alloc::{borrow, boxed, string, vec};
<a href=#406 id=406 data-nosnippet>406</a>
<a href=#407 id=407 data-nosnippet>407</a> <span class="attr">#[doc(hidden)]
<a href=#408 id=408 data-nosnippet>408</a> </span><span class="kw">pub use </span>core::{cmp, convert, fmt, iter, mem, num, ops, option, result, slice, str};
<a href=#409 id=409 data-nosnippet>409</a>
<a href=#410 id=410 data-nosnippet>410</a> <span class="doccomment">/// internal reproduction of std prelude
<a href=#411 id=411 data-nosnippet>411</a> </span><span class="attr">#[doc(hidden)]
<a href=#412 id=412 data-nosnippet>412</a> </span><span class="kw">pub mod </span>prelude {
<a href=#413 id=413 data-nosnippet>413</a> <span class="kw">pub use </span>core::prelude <span class="kw">as </span>v1;
<a href=#414 id=414 data-nosnippet>414</a> }
<a href=#415 id=415 data-nosnippet>415</a> }
<a href=#416 id=416 data-nosnippet>416</a>
<a href=#417 id=417 data-nosnippet>417</a> <span class="attr">#[cfg(feature = <span class="string">"std"</span>)]
<a href=#418 id=418 data-nosnippet>418</a> </span><span class="doccomment">/// internal std exports for no_std compatibility
<a href=#419 id=419 data-nosnippet>419</a> </span><span class="kw">pub mod </span>std {
<a href=#420 id=420 data-nosnippet>420</a> <span class="attr">#[doc(hidden)]
<a href=#421 id=421 data-nosnippet>421</a> </span><span class="kw">pub use </span>std::{
<a href=#422 id=422 data-nosnippet>422</a> alloc, borrow, boxed, cmp, collections, convert, fmt, hash, iter, mem, num, ops, option,
<a href=#423 id=423 data-nosnippet>423</a> result, slice, str, string, vec,
<a href=#424 id=424 data-nosnippet>424</a> };
<a href=#425 id=425 data-nosnippet>425</a>
<a href=#426 id=426 data-nosnippet>426</a> <span class="doccomment">/// internal reproduction of std prelude
<a href=#427 id=427 data-nosnippet>427</a> </span><span class="attr">#[doc(hidden)]
<a href=#428 id=428 data-nosnippet>428</a> </span><span class="kw">pub mod </span>prelude {
<a href=#429 id=429 data-nosnippet>429</a> <span class="kw">pub use </span>std::prelude <span class="kw">as </span>v1;
<a href=#430 id=430 data-nosnippet>430</a> }
<a href=#431 id=431 data-nosnippet>431</a> }
<a href=#432 id=432 data-nosnippet>432</a>}
<a href=#433 id=433 data-nosnippet>433</a>
<a href=#434 id=434 data-nosnippet>434</a><span class="kw">pub use </span><span class="self">self</span>::internal::<span class="kw-2">*</span>;
<a href=#435 id=435 data-nosnippet>435</a><span class="kw">pub use </span><span class="self">self</span>::traits::<span class="kw-2">*</span>;
<a href=#436 id=436 data-nosnippet>436</a>
<a href=#437 id=437 data-nosnippet>437</a><span class="attr">#[macro_use]
<a href=#438 id=438 data-nosnippet>438</a></span><span class="kw">mod </span>macros;
<a href=#439 id=439 data-nosnippet>439</a><span class="attr">#[macro_use]
<a href=#440 id=440 data-nosnippet>440</a></span><span class="kw">pub mod </span>error;
<a href=#441 id=441 data-nosnippet>441</a>
<a href=#442 id=442 data-nosnippet>442</a><span class="kw">pub mod </span>branch;
<a href=#443 id=443 data-nosnippet>443</a><span class="kw">pub mod </span>combinator;
<a href=#444 id=444 data-nosnippet>444</a><span class="kw">mod </span>internal;
<a href=#445 id=445 data-nosnippet>445</a><span class="kw">pub mod </span>multi;
<a href=#446 id=446 data-nosnippet>446</a><span class="kw">pub mod </span>sequence;
<a href=#447 id=447 data-nosnippet>447</a><span class="kw">mod </span>traits;
<a href=#448 id=448 data-nosnippet>448</a>
<a href=#449 id=449 data-nosnippet>449</a><span class="kw">pub mod </span>bits;
<a href=#450 id=450 data-nosnippet>450</a><span class="kw">pub mod </span>bytes;
<a href=#451 id=451 data-nosnippet>451</a>
<a href=#452 id=452 data-nosnippet>452</a><span class="kw">pub mod </span>character;
<a href=#453 id=453 data-nosnippet>453</a>
<a href=#454 id=454 data-nosnippet>454</a><span class="kw">mod </span>str;
<a href=#455 id=455 data-nosnippet>455</a>
<a href=#456 id=456 data-nosnippet>456</a><span class="kw">pub mod </span>number;
<a href=#457 id=457 data-nosnippet>457</a>
<a href=#458 id=458 data-nosnippet>458</a><span class="attr">#[cfg(all(feature = <span class="string">"std"</span>, any(doc, doctest, feature = <span class="string">"docsrs"</span>)))]
<a href=#459 id=459 data-nosnippet>459</a>#[cfg_attr(any(doc, doctest, feature = <span class="string">"docsrs"</span>), doc = <span class="macro">include_str!</span>(<span class="string">"../doc/nom_recipes.md"</span>))]
<a href=#460 id=460 data-nosnippet>460</a></span><span class="kw">pub mod </span>recipes {}
</code></pre></div></section></main></body></html>
+24
View File
@@ -0,0 +1,24 @@
<!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 of the Rust file `/home/newkirk/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/nom-8.0.0/src/macros.rs`."><title>macros.rs - source</title><script>if(window.location.protocol!=="file:")document.head.insertAdjacentHTML("beforeend","SourceSerif4-Regular-6b053e98.ttf.woff2,FiraSans-Italic-81dc35de.woff2,FiraSans-Regular-0fe48ade.woff2,FiraSans-MediumItalic-ccf7e434.woff2,FiraSans-Medium-e1aa3f0a.woff2,SourceCodePro-Regular-8badfe75.ttf.woff2,SourceCodePro-Semibold-aa29a496.ttf.woff2".split(",").map(f=>`<link rel="preload" as="font" type="font/woff2"href="../../static.files/${f}">`).join(""))</script><link rel="stylesheet" href="../../static.files/normalize-9960930a.css"><link rel="stylesheet" href="../../static.files/rustdoc-ca0dd0c4.css"><meta name="rustdoc-vars" data-root-path="../../" data-static-root-path="../../static.files/" data-current-crate="nom" data-themes="" data-resource-suffix="" data-rustdoc-version="1.93.1 (01f6ddf75 2026-02-11) (Arch Linux rust 1:1.93.1-1)" data-channel="1.93.1" data-search-js="search-9e2438ea.js" data-stringdex-js="stringdex-a3946164.js" data-settings-js="settings-c38705f0.js" ><script src="../../static.files/storage-e2aeef58.js"></script><script defer src="../../static.files/src-script-813739b1.js"></script><script defer src="../../src-files.js"></script><script defer src="../../static.files/main-a410ff4d.js"></script><noscript><link rel="stylesheet" href="../../static.files/noscript-263c88ec.css"></noscript><link rel="alternate icon" type="image/png" href="../../static.files/favicon-32x32-eab170b8.png"><link rel="icon" type="image/svg+xml" href="../../static.files/favicon-044be391.svg"></head><body class="rustdoc src"><!--[if lte IE 11]><div class="warning">This old browser is unsupported and will most likely display funky things.</div><![endif]--><nav class="sidebar"><div class="src-sidebar-title"><h2>Files</h2></div></nav><div class="sidebar-resizer" title="Drag to resize sidebar"></div><main><section id="main-content" class="content"><div class="main-heading"><h1><div class="sub-heading">nom/</div>macros.rs</h1><rustdoc-toolbar></rustdoc-toolbar></div><div class="example-wrap digits-2"><pre class="rust"><code><a href=#1 id=1 data-nosnippet>1</a><span class="macro">macro_rules!</span> succ (
<a href=#2 id=2 data-nosnippet>2</a> (<span class="number">0</span>, <span class="macro-nonterminal">$submac</span>:<span class="macro">ident !</span> ($(<span class="macro-nonterminal">$rest</span>:tt)<span class="kw-2">*</span>)) =&gt; (<span class="macro-nonterminal">$submac</span>!(<span class="number">1</span>, $(<span class="macro-nonterminal">$rest</span>)<span class="kw-2">*</span>));
<a href=#3 id=3 data-nosnippet>3</a> (<span class="number">1</span>, <span class="macro-nonterminal">$submac</span>:<span class="macro">ident !</span> ($(<span class="macro-nonterminal">$rest</span>:tt)<span class="kw-2">*</span>)) =&gt; (<span class="macro-nonterminal">$submac</span>!(<span class="number">2</span>, $(<span class="macro-nonterminal">$rest</span>)<span class="kw-2">*</span>));
<a href=#4 id=4 data-nosnippet>4</a> (<span class="number">2</span>, <span class="macro-nonterminal">$submac</span>:<span class="macro">ident !</span> ($(<span class="macro-nonterminal">$rest</span>:tt)<span class="kw-2">*</span>)) =&gt; (<span class="macro-nonterminal">$submac</span>!(<span class="number">3</span>, $(<span class="macro-nonterminal">$rest</span>)<span class="kw-2">*</span>));
<a href=#5 id=5 data-nosnippet>5</a> (<span class="number">3</span>, <span class="macro-nonterminal">$submac</span>:<span class="macro">ident !</span> ($(<span class="macro-nonterminal">$rest</span>:tt)<span class="kw-2">*</span>)) =&gt; (<span class="macro-nonterminal">$submac</span>!(<span class="number">4</span>, $(<span class="macro-nonterminal">$rest</span>)<span class="kw-2">*</span>));
<a href=#6 id=6 data-nosnippet>6</a> (<span class="number">4</span>, <span class="macro-nonterminal">$submac</span>:<span class="macro">ident !</span> ($(<span class="macro-nonterminal">$rest</span>:tt)<span class="kw-2">*</span>)) =&gt; (<span class="macro-nonterminal">$submac</span>!(<span class="number">5</span>, $(<span class="macro-nonterminal">$rest</span>)<span class="kw-2">*</span>));
<a href=#7 id=7 data-nosnippet>7</a> (<span class="number">5</span>, <span class="macro-nonterminal">$submac</span>:<span class="macro">ident !</span> ($(<span class="macro-nonterminal">$rest</span>:tt)<span class="kw-2">*</span>)) =&gt; (<span class="macro-nonterminal">$submac</span>!(<span class="number">6</span>, $(<span class="macro-nonterminal">$rest</span>)<span class="kw-2">*</span>));
<a href=#8 id=8 data-nosnippet>8</a> (<span class="number">6</span>, <span class="macro-nonterminal">$submac</span>:<span class="macro">ident !</span> ($(<span class="macro-nonterminal">$rest</span>:tt)<span class="kw-2">*</span>)) =&gt; (<span class="macro-nonterminal">$submac</span>!(<span class="number">7</span>, $(<span class="macro-nonterminal">$rest</span>)<span class="kw-2">*</span>));
<a href=#9 id=9 data-nosnippet>9</a> (<span class="number">7</span>, <span class="macro-nonterminal">$submac</span>:<span class="macro">ident !</span> ($(<span class="macro-nonterminal">$rest</span>:tt)<span class="kw-2">*</span>)) =&gt; (<span class="macro-nonterminal">$submac</span>!(<span class="number">8</span>, $(<span class="macro-nonterminal">$rest</span>)<span class="kw-2">*</span>));
<a href=#10 id=10 data-nosnippet>10</a> (<span class="number">8</span>, <span class="macro-nonterminal">$submac</span>:<span class="macro">ident !</span> ($(<span class="macro-nonterminal">$rest</span>:tt)<span class="kw-2">*</span>)) =&gt; (<span class="macro-nonterminal">$submac</span>!(<span class="number">9</span>, $(<span class="macro-nonterminal">$rest</span>)<span class="kw-2">*</span>));
<a href=#11 id=11 data-nosnippet>11</a> (<span class="number">9</span>, <span class="macro-nonterminal">$submac</span>:<span class="macro">ident !</span> ($(<span class="macro-nonterminal">$rest</span>:tt)<span class="kw-2">*</span>)) =&gt; (<span class="macro-nonterminal">$submac</span>!(<span class="number">10</span>, $(<span class="macro-nonterminal">$rest</span>)<span class="kw-2">*</span>));
<a href=#12 id=12 data-nosnippet>12</a> (<span class="number">10</span>, <span class="macro-nonterminal">$submac</span>:<span class="macro">ident !</span> ($(<span class="macro-nonterminal">$rest</span>:tt)<span class="kw-2">*</span>)) =&gt; (<span class="macro-nonterminal">$submac</span>!(<span class="number">11</span>, $(<span class="macro-nonterminal">$rest</span>)<span class="kw-2">*</span>));
<a href=#13 id=13 data-nosnippet>13</a> (<span class="number">11</span>, <span class="macro-nonterminal">$submac</span>:<span class="macro">ident !</span> ($(<span class="macro-nonterminal">$rest</span>:tt)<span class="kw-2">*</span>)) =&gt; (<span class="macro-nonterminal">$submac</span>!(<span class="number">12</span>, $(<span class="macro-nonterminal">$rest</span>)<span class="kw-2">*</span>));
<a href=#14 id=14 data-nosnippet>14</a> (<span class="number">12</span>, <span class="macro-nonterminal">$submac</span>:<span class="macro">ident !</span> ($(<span class="macro-nonterminal">$rest</span>:tt)<span class="kw-2">*</span>)) =&gt; (<span class="macro-nonterminal">$submac</span>!(<span class="number">13</span>, $(<span class="macro-nonterminal">$rest</span>)<span class="kw-2">*</span>));
<a href=#15 id=15 data-nosnippet>15</a> (<span class="number">13</span>, <span class="macro-nonterminal">$submac</span>:<span class="macro">ident !</span> ($(<span class="macro-nonterminal">$rest</span>:tt)<span class="kw-2">*</span>)) =&gt; (<span class="macro-nonterminal">$submac</span>!(<span class="number">14</span>, $(<span class="macro-nonterminal">$rest</span>)<span class="kw-2">*</span>));
<a href=#16 id=16 data-nosnippet>16</a> (<span class="number">14</span>, <span class="macro-nonterminal">$submac</span>:<span class="macro">ident !</span> ($(<span class="macro-nonterminal">$rest</span>:tt)<span class="kw-2">*</span>)) =&gt; (<span class="macro-nonterminal">$submac</span>!(<span class="number">15</span>, $(<span class="macro-nonterminal">$rest</span>)<span class="kw-2">*</span>));
<a href=#17 id=17 data-nosnippet>17</a> (<span class="number">15</span>, <span class="macro-nonterminal">$submac</span>:<span class="macro">ident !</span> ($(<span class="macro-nonterminal">$rest</span>:tt)<span class="kw-2">*</span>)) =&gt; (<span class="macro-nonterminal">$submac</span>!(<span class="number">16</span>, $(<span class="macro-nonterminal">$rest</span>)<span class="kw-2">*</span>));
<a href=#18 id=18 data-nosnippet>18</a> (<span class="number">16</span>, <span class="macro-nonterminal">$submac</span>:<span class="macro">ident !</span> ($(<span class="macro-nonterminal">$rest</span>:tt)<span class="kw-2">*</span>)) =&gt; (<span class="macro-nonterminal">$submac</span>!(<span class="number">17</span>, $(<span class="macro-nonterminal">$rest</span>)<span class="kw-2">*</span>));
<a href=#19 id=19 data-nosnippet>19</a> (<span class="number">17</span>, <span class="macro-nonterminal">$submac</span>:<span class="macro">ident !</span> ($(<span class="macro-nonterminal">$rest</span>:tt)<span class="kw-2">*</span>)) =&gt; (<span class="macro-nonterminal">$submac</span>!(<span class="number">18</span>, $(<span class="macro-nonterminal">$rest</span>)<span class="kw-2">*</span>));
<a href=#20 id=20 data-nosnippet>20</a> (<span class="number">18</span>, <span class="macro-nonterminal">$submac</span>:<span class="macro">ident !</span> ($(<span class="macro-nonterminal">$rest</span>:tt)<span class="kw-2">*</span>)) =&gt; (<span class="macro-nonterminal">$submac</span>!(<span class="number">19</span>, $(<span class="macro-nonterminal">$rest</span>)<span class="kw-2">*</span>));
<a href=#21 id=21 data-nosnippet>21</a> (<span class="number">19</span>, <span class="macro-nonterminal">$submac</span>:<span class="macro">ident !</span> ($(<span class="macro-nonterminal">$rest</span>:tt)<span class="kw-2">*</span>)) =&gt; (<span class="macro-nonterminal">$submac</span>!(<span class="number">20</span>, $(<span class="macro-nonterminal">$rest</span>)<span class="kw-2">*</span>));
<a href=#22 id=22 data-nosnippet>22</a> (<span class="number">20</span>, <span class="macro-nonterminal">$submac</span>:<span class="macro">ident !</span> ($(<span class="macro-nonterminal">$rest</span>:tt)<span class="kw-2">*</span>)) =&gt; (<span class="macro-nonterminal">$submac</span>!(<span class="number">21</span>, $(<span class="macro-nonterminal">$rest</span>)<span class="kw-2">*</span>));
<a href=#23 id=23 data-nosnippet>23</a>);
</code></pre></div></section></main></body></html>
File diff suppressed because it is too large Load Diff
File diff suppressed because it is too large Load Diff
File diff suppressed because it is too large Load Diff
File diff suppressed because it is too large Load Diff
+322
View File
@@ -0,0 +1,322 @@
<!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 of the Rust file `/home/newkirk/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/nom-8.0.0/src/sequence/mod.rs`."><title>mod.rs - source</title><script>if(window.location.protocol!=="file:")document.head.insertAdjacentHTML("beforeend","SourceSerif4-Regular-6b053e98.ttf.woff2,FiraSans-Italic-81dc35de.woff2,FiraSans-Regular-0fe48ade.woff2,FiraSans-MediumItalic-ccf7e434.woff2,FiraSans-Medium-e1aa3f0a.woff2,SourceCodePro-Regular-8badfe75.ttf.woff2,SourceCodePro-Semibold-aa29a496.ttf.woff2".split(",").map(f=>`<link rel="preload" as="font" type="font/woff2"href="../../../static.files/${f}">`).join(""))</script><link rel="stylesheet" href="../../../static.files/normalize-9960930a.css"><link rel="stylesheet" href="../../../static.files/rustdoc-ca0dd0c4.css"><meta name="rustdoc-vars" data-root-path="../../../" data-static-root-path="../../../static.files/" data-current-crate="nom" data-themes="" data-resource-suffix="" data-rustdoc-version="1.93.1 (01f6ddf75 2026-02-11) (Arch Linux rust 1:1.93.1-1)" data-channel="1.93.1" data-search-js="search-9e2438ea.js" data-stringdex-js="stringdex-a3946164.js" data-settings-js="settings-c38705f0.js" ><script src="../../../static.files/storage-e2aeef58.js"></script><script defer src="../../../static.files/src-script-813739b1.js"></script><script defer src="../../../src-files.js"></script><script defer src="../../../static.files/main-a410ff4d.js"></script><noscript><link rel="stylesheet" href="../../../static.files/noscript-263c88ec.css"></noscript><link rel="alternate icon" type="image/png" href="../../../static.files/favicon-32x32-eab170b8.png"><link rel="icon" type="image/svg+xml" href="../../../static.files/favicon-044be391.svg"></head><body class="rustdoc src"><!--[if lte IE 11]><div class="warning">This old browser is unsupported and will most likely display funky things.</div><![endif]--><nav class="sidebar"><div class="src-sidebar-title"><h2>Files</h2></div></nav><div class="sidebar-resizer" title="Drag to resize sidebar"></div><main><section id="main-content" class="content"><div class="main-heading"><h1><div class="sub-heading">nom/sequence/</div>mod.rs</h1><rustdoc-toolbar></rustdoc-toolbar></div><div class="example-wrap digits-3"><pre class="rust"><code><a href=#1 id=1 data-nosnippet>1</a><span class="doccomment">//! Combinators applying parsers in sequence
<a href=#2 id=2 data-nosnippet>2</a>
<a href=#3 id=3 data-nosnippet>3</a></span><span class="attr">#[cfg(test)]
<a href=#4 id=4 data-nosnippet>4</a></span><span class="kw">mod </span>tests;
<a href=#5 id=5 data-nosnippet>5</a>
<a href=#6 id=6 data-nosnippet>6</a><span class="kw">use </span><span class="kw">crate</span>::error::ParseError;
<a href=#7 id=7 data-nosnippet>7</a><span class="kw">use </span><span class="kw">crate</span>::internal::{IResult, Parser};
<a href=#8 id=8 data-nosnippet>8</a><span class="kw">use crate</span>::{Check, OutputM, OutputMode, PResult};
<a href=#9 id=9 data-nosnippet>9</a>
<a href=#10 id=10 data-nosnippet>10</a><span class="doccomment">/// Gets an object from the first parser,
<a href=#11 id=11 data-nosnippet>11</a>/// then gets another object from the second parser.
<a href=#12 id=12 data-nosnippet>12</a>///
<a href=#13 id=13 data-nosnippet>13</a>/// # Arguments
<a href=#14 id=14 data-nosnippet>14</a>/// * `first` The first parser to apply.
<a href=#15 id=15 data-nosnippet>15</a>/// * `second` The second parser to apply.
<a href=#16 id=16 data-nosnippet>16</a>///
<a href=#17 id=17 data-nosnippet>17</a>/// # Example
<a href=#18 id=18 data-nosnippet>18</a>/// ```rust
<a href=#19 id=19 data-nosnippet>19</a>/// use nom::sequence::pair;
<a href=#20 id=20 data-nosnippet>20</a>/// use nom::bytes::complete::tag;
<a href=#21 id=21 data-nosnippet>21</a>/// use nom::{error::ErrorKind, Err, Parser};
<a href=#22 id=22 data-nosnippet>22</a>///
<a href=#23 id=23 data-nosnippet>23</a>/// let mut parser = pair(tag("abc"), tag("efg"));
<a href=#24 id=24 data-nosnippet>24</a>///
<a href=#25 id=25 data-nosnippet>25</a>/// assert_eq!(parser.parse("abcefg"), Ok(("", ("abc", "efg"))));
<a href=#26 id=26 data-nosnippet>26</a>/// assert_eq!(parser.parse("abcefghij"), Ok(("hij", ("abc", "efg"))));
<a href=#27 id=27 data-nosnippet>27</a>/// assert_eq!(parser.parse(""), Err(Err::Error(("", ErrorKind::Tag))));
<a href=#28 id=28 data-nosnippet>28</a>/// assert_eq!(parser.parse("123"), Err(Err::Error(("123", ErrorKind::Tag))));
<a href=#29 id=29 data-nosnippet>29</a>/// ```
<a href=#30 id=30 data-nosnippet>30</a></span><span class="kw">pub fn </span>pair&lt;I, O1, O2, E: ParseError&lt;I&gt;, F, G&gt;(
<a href=#31 id=31 data-nosnippet>31</a> first: F,
<a href=#32 id=32 data-nosnippet>32</a> second: G,
<a href=#33 id=33 data-nosnippet>33</a>) -&gt; <span class="kw">impl </span>Parser&lt;I, Output = (O1, O2), Error = E&gt;
<a href=#34 id=34 data-nosnippet>34</a><span class="kw">where
<a href=#35 id=35 data-nosnippet>35</a> </span>F: Parser&lt;I, Output = O1, Error = E&gt;,
<a href=#36 id=36 data-nosnippet>36</a> G: Parser&lt;I, Output = O2, Error = E&gt;,
<a href=#37 id=37 data-nosnippet>37</a>{
<a href=#38 id=38 data-nosnippet>38</a> first.and(second)
<a href=#39 id=39 data-nosnippet>39</a>}
<a href=#40 id=40 data-nosnippet>40</a>
<a href=#41 id=41 data-nosnippet>41</a><span class="doccomment">/// Matches an object from the first parser and discards it,
<a href=#42 id=42 data-nosnippet>42</a>/// then gets an object from the second parser.
<a href=#43 id=43 data-nosnippet>43</a>///
<a href=#44 id=44 data-nosnippet>44</a>/// # Arguments
<a href=#45 id=45 data-nosnippet>45</a>/// * `first` The opening parser.
<a href=#46 id=46 data-nosnippet>46</a>/// * `second` The second parser to get object.
<a href=#47 id=47 data-nosnippet>47</a>///
<a href=#48 id=48 data-nosnippet>48</a>/// ```rust
<a href=#49 id=49 data-nosnippet>49</a>/// # use nom::{Err, error::ErrorKind, Needed, Parser};
<a href=#50 id=50 data-nosnippet>50</a>/// # use nom::Needed::Size;
<a href=#51 id=51 data-nosnippet>51</a>/// use nom::sequence::preceded;
<a href=#52 id=52 data-nosnippet>52</a>/// use nom::bytes::complete::tag;
<a href=#53 id=53 data-nosnippet>53</a>///
<a href=#54 id=54 data-nosnippet>54</a>/// let mut parser = preceded(tag("abc"), tag("efg"));
<a href=#55 id=55 data-nosnippet>55</a>///
<a href=#56 id=56 data-nosnippet>56</a>/// assert_eq!(parser.parse("abcefg"), Ok(("", "efg")));
<a href=#57 id=57 data-nosnippet>57</a>/// assert_eq!(parser.parse("abcefghij"), Ok(("hij", "efg")));
<a href=#58 id=58 data-nosnippet>58</a>/// assert_eq!(parser.parse(""), Err(Err::Error(("", ErrorKind::Tag))));
<a href=#59 id=59 data-nosnippet>59</a>/// assert_eq!(parser.parse("123"), Err(Err::Error(("123", ErrorKind::Tag))));
<a href=#60 id=60 data-nosnippet>60</a>/// ```
<a href=#61 id=61 data-nosnippet>61</a></span><span class="kw">pub fn </span>preceded&lt;I, O, E: ParseError&lt;I&gt;, F, G&gt;(
<a href=#62 id=62 data-nosnippet>62</a> first: F,
<a href=#63 id=63 data-nosnippet>63</a> second: G,
<a href=#64 id=64 data-nosnippet>64</a>) -&gt; <span class="kw">impl </span>Parser&lt;I, Output = O, Error = E&gt;
<a href=#65 id=65 data-nosnippet>65</a><span class="kw">where
<a href=#66 id=66 data-nosnippet>66</a> </span>F: Parser&lt;I, Error = E&gt;,
<a href=#67 id=67 data-nosnippet>67</a> G: Parser&lt;I, Output = O, Error = E&gt;,
<a href=#68 id=68 data-nosnippet>68</a>{
<a href=#69 id=69 data-nosnippet>69</a> Preceded {
<a href=#70 id=70 data-nosnippet>70</a> f: first,
<a href=#71 id=71 data-nosnippet>71</a> g: second,
<a href=#72 id=72 data-nosnippet>72</a> }
<a href=#73 id=73 data-nosnippet>73</a>}
<a href=#74 id=74 data-nosnippet>74</a>
<a href=#75 id=75 data-nosnippet>75</a><span class="doccomment">/// a
<a href=#76 id=76 data-nosnippet>76</a></span><span class="kw">pub struct </span>Preceded&lt;F, G&gt; {
<a href=#77 id=77 data-nosnippet>77</a> f: F,
<a href=#78 id=78 data-nosnippet>78</a> g: G,
<a href=#79 id=79 data-nosnippet>79</a>}
<a href=#80 id=80 data-nosnippet>80</a>
<a href=#81 id=81 data-nosnippet>81</a><span class="kw">impl</span>&lt;I, E: ParseError&lt;I&gt;, F: Parser&lt;I, Error = E&gt;, G: Parser&lt;I, Error = E&gt;&gt; Parser&lt;I&gt;
<a href=#82 id=82 data-nosnippet>82</a> <span class="kw">for </span>Preceded&lt;F, G&gt;
<a href=#83 id=83 data-nosnippet>83</a>{
<a href=#84 id=84 data-nosnippet>84</a> <span class="kw">type </span>Output = &lt;G <span class="kw">as </span>Parser&lt;I&gt;&gt;::Output;
<a href=#85 id=85 data-nosnippet>85</a> <span class="kw">type </span>Error = E;
<a href=#86 id=86 data-nosnippet>86</a>
<a href=#87 id=87 data-nosnippet>87</a> <span class="attr">#[inline(always)]
<a href=#88 id=88 data-nosnippet>88</a> </span><span class="kw">fn </span>process&lt;OM: OutputMode&gt;(<span class="kw-2">&amp;mut </span><span class="self">self</span>, i: I) -&gt; PResult&lt;OM, I, <span class="self">Self</span>::Output, <span class="self">Self</span>::Error&gt; {
<a href=#89 id=89 data-nosnippet>89</a> <span class="kw">let </span>(i, <span class="kw">_</span>) = <span class="self">self
<a href=#90 id=90 data-nosnippet>90</a> </span>.f
<a href=#91 id=91 data-nosnippet>91</a> .process::&lt;OutputM&lt;Check, OM::Error, OM::Incomplete&gt;&gt;(i)<span class="question-mark">?</span>;
<a href=#92 id=92 data-nosnippet>92</a> <span class="kw">let </span>(i, o2) = <span class="self">self</span>.g.process::&lt;OM&gt;(i)<span class="question-mark">?</span>;
<a href=#93 id=93 data-nosnippet>93</a>
<a href=#94 id=94 data-nosnippet>94</a> <span class="prelude-val">Ok</span>((i, o2))
<a href=#95 id=95 data-nosnippet>95</a> }
<a href=#96 id=96 data-nosnippet>96</a>}
<a href=#97 id=97 data-nosnippet>97</a>
<a href=#98 id=98 data-nosnippet>98</a><span class="doccomment">/// Gets an object from the first parser,
<a href=#99 id=99 data-nosnippet>99</a>/// then matches an object from the second parser and discards it.
<a href=#100 id=100 data-nosnippet>100</a>///
<a href=#101 id=101 data-nosnippet>101</a>/// # Arguments
<a href=#102 id=102 data-nosnippet>102</a>/// * `first` The first parser to apply.
<a href=#103 id=103 data-nosnippet>103</a>/// * `second` The second parser to match an object.
<a href=#104 id=104 data-nosnippet>104</a>///
<a href=#105 id=105 data-nosnippet>105</a>/// ```rust
<a href=#106 id=106 data-nosnippet>106</a>/// # use nom::{Err, error::ErrorKind, Needed, Parser};
<a href=#107 id=107 data-nosnippet>107</a>/// # use nom::Needed::Size;
<a href=#108 id=108 data-nosnippet>108</a>/// use nom::sequence::terminated;
<a href=#109 id=109 data-nosnippet>109</a>/// use nom::bytes::complete::tag;
<a href=#110 id=110 data-nosnippet>110</a>///
<a href=#111 id=111 data-nosnippet>111</a>/// let mut parser = terminated(tag("abc"), tag("efg"));
<a href=#112 id=112 data-nosnippet>112</a>///
<a href=#113 id=113 data-nosnippet>113</a>/// assert_eq!(parser.parse("abcefg"), Ok(("", "abc")));
<a href=#114 id=114 data-nosnippet>114</a>/// assert_eq!(parser.parse("abcefghij"), Ok(("hij", "abc")));
<a href=#115 id=115 data-nosnippet>115</a>/// assert_eq!(parser.parse(""), Err(Err::Error(("", ErrorKind::Tag))));
<a href=#116 id=116 data-nosnippet>116</a>/// assert_eq!(parser.parse("123"), Err(Err::Error(("123", ErrorKind::Tag))));
<a href=#117 id=117 data-nosnippet>117</a>/// ```
<a href=#118 id=118 data-nosnippet>118</a></span><span class="kw">pub fn </span>terminated&lt;I, O, E: ParseError&lt;I&gt;, F, G&gt;(
<a href=#119 id=119 data-nosnippet>119</a> first: F,
<a href=#120 id=120 data-nosnippet>120</a> second: G,
<a href=#121 id=121 data-nosnippet>121</a>) -&gt; <span class="kw">impl </span>Parser&lt;I, Output = O, Error = E&gt;
<a href=#122 id=122 data-nosnippet>122</a><span class="kw">where
<a href=#123 id=123 data-nosnippet>123</a> </span>F: Parser&lt;I, Output = O, Error = E&gt;,
<a href=#124 id=124 data-nosnippet>124</a> G: Parser&lt;I, Error = E&gt;,
<a href=#125 id=125 data-nosnippet>125</a>{
<a href=#126 id=126 data-nosnippet>126</a> Terminated {
<a href=#127 id=127 data-nosnippet>127</a> f: first,
<a href=#128 id=128 data-nosnippet>128</a> g: second,
<a href=#129 id=129 data-nosnippet>129</a> }
<a href=#130 id=130 data-nosnippet>130</a>}
<a href=#131 id=131 data-nosnippet>131</a>
<a href=#132 id=132 data-nosnippet>132</a><span class="doccomment">/// a
<a href=#133 id=133 data-nosnippet>133</a></span><span class="kw">pub struct </span>Terminated&lt;F, G&gt; {
<a href=#134 id=134 data-nosnippet>134</a> f: F,
<a href=#135 id=135 data-nosnippet>135</a> g: G,
<a href=#136 id=136 data-nosnippet>136</a>}
<a href=#137 id=137 data-nosnippet>137</a>
<a href=#138 id=138 data-nosnippet>138</a><span class="kw">impl</span>&lt;I, E: ParseError&lt;I&gt;, F: Parser&lt;I, Error = E&gt;, G: Parser&lt;I, Error = E&gt;&gt; Parser&lt;I&gt;
<a href=#139 id=139 data-nosnippet>139</a> <span class="kw">for </span>Terminated&lt;F, G&gt;
<a href=#140 id=140 data-nosnippet>140</a>{
<a href=#141 id=141 data-nosnippet>141</a> <span class="kw">type </span>Output = &lt;F <span class="kw">as </span>Parser&lt;I&gt;&gt;::Output;
<a href=#142 id=142 data-nosnippet>142</a> <span class="kw">type </span>Error = E;
<a href=#143 id=143 data-nosnippet>143</a>
<a href=#144 id=144 data-nosnippet>144</a> <span class="attr">#[inline(always)]
<a href=#145 id=145 data-nosnippet>145</a> </span><span class="kw">fn </span>process&lt;OM: OutputMode&gt;(<span class="kw-2">&amp;mut </span><span class="self">self</span>, i: I) -&gt; PResult&lt;OM, I, <span class="self">Self</span>::Output, <span class="self">Self</span>::Error&gt; {
<a href=#146 id=146 data-nosnippet>146</a> <span class="kw">let </span>(i, o1) = <span class="self">self</span>.f.process::&lt;OM&gt;(i)<span class="question-mark">?</span>;
<a href=#147 id=147 data-nosnippet>147</a> <span class="kw">let </span>(i, <span class="kw">_</span>) = <span class="self">self
<a href=#148 id=148 data-nosnippet>148</a> </span>.g
<a href=#149 id=149 data-nosnippet>149</a> .process::&lt;OutputM&lt;Check, OM::Error, OM::Incomplete&gt;&gt;(i)<span class="question-mark">?</span>;
<a href=#150 id=150 data-nosnippet>150</a>
<a href=#151 id=151 data-nosnippet>151</a> <span class="prelude-val">Ok</span>((i, o1))
<a href=#152 id=152 data-nosnippet>152</a> }
<a href=#153 id=153 data-nosnippet>153</a>}
<a href=#154 id=154 data-nosnippet>154</a>
<a href=#155 id=155 data-nosnippet>155</a><span class="doccomment">/// Gets an object from the first parser,
<a href=#156 id=156 data-nosnippet>156</a>/// then matches an object from the sep_parser and discards it,
<a href=#157 id=157 data-nosnippet>157</a>/// then gets another object from the second parser.
<a href=#158 id=158 data-nosnippet>158</a>///
<a href=#159 id=159 data-nosnippet>159</a>/// # Arguments
<a href=#160 id=160 data-nosnippet>160</a>/// * `first` The first parser to apply.
<a href=#161 id=161 data-nosnippet>161</a>/// * `sep` The separator parser to apply.
<a href=#162 id=162 data-nosnippet>162</a>/// * `second` The second parser to apply.
<a href=#163 id=163 data-nosnippet>163</a>///
<a href=#164 id=164 data-nosnippet>164</a>/// ```rust
<a href=#165 id=165 data-nosnippet>165</a>/// # use nom::{Err, error::ErrorKind, Needed, Parser};
<a href=#166 id=166 data-nosnippet>166</a>/// # use nom::Needed::Size;
<a href=#167 id=167 data-nosnippet>167</a>/// use nom::sequence::separated_pair;
<a href=#168 id=168 data-nosnippet>168</a>/// use nom::bytes::complete::tag;
<a href=#169 id=169 data-nosnippet>169</a>///
<a href=#170 id=170 data-nosnippet>170</a>/// let mut parser = separated_pair(tag("abc"), tag("|"), tag("efg"));
<a href=#171 id=171 data-nosnippet>171</a>///
<a href=#172 id=172 data-nosnippet>172</a>/// assert_eq!(parser.parse("abc|efg"), Ok(("", ("abc", "efg"))));
<a href=#173 id=173 data-nosnippet>173</a>/// assert_eq!(parser.parse("abc|efghij"), Ok(("hij", ("abc", "efg"))));
<a href=#174 id=174 data-nosnippet>174</a>/// assert_eq!(parser.parse(""), Err(Err::Error(("", ErrorKind::Tag))));
<a href=#175 id=175 data-nosnippet>175</a>/// assert_eq!(parser.parse("123"), Err(Err::Error(("123", ErrorKind::Tag))));
<a href=#176 id=176 data-nosnippet>176</a>/// ```
<a href=#177 id=177 data-nosnippet>177</a></span><span class="kw">pub fn </span>separated_pair&lt;I, O1, O2, E: ParseError&lt;I&gt;, F, G, H&gt;(
<a href=#178 id=178 data-nosnippet>178</a> first: F,
<a href=#179 id=179 data-nosnippet>179</a> sep: G,
<a href=#180 id=180 data-nosnippet>180</a> second: H,
<a href=#181 id=181 data-nosnippet>181</a>) -&gt; <span class="kw">impl </span>Parser&lt;I, Output = (O1, O2), Error = E&gt;
<a href=#182 id=182 data-nosnippet>182</a><span class="kw">where
<a href=#183 id=183 data-nosnippet>183</a> </span>F: Parser&lt;I, Output = O1, Error = E&gt;,
<a href=#184 id=184 data-nosnippet>184</a> G: Parser&lt;I, Error = E&gt;,
<a href=#185 id=185 data-nosnippet>185</a> H: Parser&lt;I, Output = O2, Error = E&gt;,
<a href=#186 id=186 data-nosnippet>186</a>{
<a href=#187 id=187 data-nosnippet>187</a> first.and(preceded(sep, second))
<a href=#188 id=188 data-nosnippet>188</a>}
<a href=#189 id=189 data-nosnippet>189</a>
<a href=#190 id=190 data-nosnippet>190</a><span class="doccomment">/// Matches an object from the first parser and discards it,
<a href=#191 id=191 data-nosnippet>191</a>/// then gets an object from the second parser,
<a href=#192 id=192 data-nosnippet>192</a>/// and finally matches an object from the third parser and discards it.
<a href=#193 id=193 data-nosnippet>193</a>///
<a href=#194 id=194 data-nosnippet>194</a>/// # Arguments
<a href=#195 id=195 data-nosnippet>195</a>/// * `first` The first parser to apply and discard.
<a href=#196 id=196 data-nosnippet>196</a>/// * `second` The second parser to apply.
<a href=#197 id=197 data-nosnippet>197</a>/// * `third` The third parser to apply and discard.
<a href=#198 id=198 data-nosnippet>198</a>///
<a href=#199 id=199 data-nosnippet>199</a>/// ```rust
<a href=#200 id=200 data-nosnippet>200</a>/// # use nom::{Err, error::ErrorKind, Needed, Parser};
<a href=#201 id=201 data-nosnippet>201</a>/// # use nom::Needed::Size;
<a href=#202 id=202 data-nosnippet>202</a>/// use nom::sequence::delimited;
<a href=#203 id=203 data-nosnippet>203</a>/// use nom::bytes::complete::tag;
<a href=#204 id=204 data-nosnippet>204</a>///
<a href=#205 id=205 data-nosnippet>205</a>/// let mut parser = delimited(tag("("), tag("abc"), tag(")"));
<a href=#206 id=206 data-nosnippet>206</a>///
<a href=#207 id=207 data-nosnippet>207</a>/// assert_eq!(parser.parse("(abc)"), Ok(("", "abc")));
<a href=#208 id=208 data-nosnippet>208</a>/// assert_eq!(parser.parse("(abc)def"), Ok(("def", "abc")));
<a href=#209 id=209 data-nosnippet>209</a>/// assert_eq!(parser.parse(""), Err(Err::Error(("", ErrorKind::Tag))));
<a href=#210 id=210 data-nosnippet>210</a>/// assert_eq!(parser.parse("123"), Err(Err::Error(("123", ErrorKind::Tag))));
<a href=#211 id=211 data-nosnippet>211</a>/// ```
<a href=#212 id=212 data-nosnippet>212</a></span><span class="kw">pub fn </span>delimited&lt;I, O, E: ParseError&lt;I&gt;, F, G, H&gt;(
<a href=#213 id=213 data-nosnippet>213</a> first: F,
<a href=#214 id=214 data-nosnippet>214</a> second: G,
<a href=#215 id=215 data-nosnippet>215</a> third: H,
<a href=#216 id=216 data-nosnippet>216</a>) -&gt; <span class="kw">impl </span>Parser&lt;I, Output = O, Error = E&gt;
<a href=#217 id=217 data-nosnippet>217</a><span class="kw">where
<a href=#218 id=218 data-nosnippet>218</a> </span>F: Parser&lt;I, Error = E&gt;,
<a href=#219 id=219 data-nosnippet>219</a> G: Parser&lt;I, Output = O, Error = E&gt;,
<a href=#220 id=220 data-nosnippet>220</a> H: Parser&lt;I, Error = E&gt;,
<a href=#221 id=221 data-nosnippet>221</a>{
<a href=#222 id=222 data-nosnippet>222</a> preceded(first, terminated(second, third))
<a href=#223 id=223 data-nosnippet>223</a>}
<a href=#224 id=224 data-nosnippet>224</a>
<a href=#225 id=225 data-nosnippet>225</a><span class="doccomment">/// Helper trait for the tuple combinator.
<a href=#226 id=226 data-nosnippet>226</a>///
<a href=#227 id=227 data-nosnippet>227</a>/// This trait is implemented for tuples of parsers of up to 21 elements.
<a href=#228 id=228 data-nosnippet>228</a></span><span class="attr">#[deprecated(since = <span class="string">"8.0.0"</span>, note = <span class="string">"`Parser` is directly implemented for tuples"</span>)]
<a href=#229 id=229 data-nosnippet>229</a>#[allow(deprecated)]
<a href=#230 id=230 data-nosnippet>230</a></span><span class="kw">pub trait </span>Tuple&lt;I, O, E&gt; {
<a href=#231 id=231 data-nosnippet>231</a> <span class="doccomment">/// Parses the input and returns a tuple of results of each parser.
<a href=#232 id=232 data-nosnippet>232</a> </span><span class="kw">fn </span>parse_tuple(<span class="kw-2">&amp;mut </span><span class="self">self</span>, input: I) -&gt; IResult&lt;I, O, E&gt;;
<a href=#233 id=233 data-nosnippet>233</a>}
<a href=#234 id=234 data-nosnippet>234</a>
<a href=#235 id=235 data-nosnippet>235</a><span class="attr">#[allow(deprecated)]
<a href=#236 id=236 data-nosnippet>236</a></span><span class="kw">impl</span>&lt;Input, Output, Error: ParseError&lt;Input&gt;, F: Parser&lt;Input, Output = Output, Error = Error&gt;&gt;
<a href=#237 id=237 data-nosnippet>237</a> Tuple&lt;Input, (Output,), Error&gt; <span class="kw">for </span>(F,)
<a href=#238 id=238 data-nosnippet>238</a>{
<a href=#239 id=239 data-nosnippet>239</a> <span class="kw">fn </span>parse_tuple(<span class="kw-2">&amp;mut </span><span class="self">self</span>, input: Input) -&gt; IResult&lt;Input, (Output,), Error&gt; {
<a href=#240 id=240 data-nosnippet>240</a> <span class="self">self</span>.<span class="number">0</span>.parse(input).map(|(i, o)| (i, (o,)))
<a href=#241 id=241 data-nosnippet>241</a> }
<a href=#242 id=242 data-nosnippet>242</a>}
<a href=#243 id=243 data-nosnippet>243</a>
<a href=#244 id=244 data-nosnippet>244</a><span class="macro">macro_rules!</span> tuple_trait(
<a href=#245 id=245 data-nosnippet>245</a> (<span class="macro-nonterminal">$name1</span>:ident <span class="macro-nonterminal">$ty1</span>:ident, <span class="macro-nonterminal">$name2</span>: ident <span class="macro-nonterminal">$ty2</span>:ident, $(<span class="macro-nonterminal">$name</span>:ident <span class="macro-nonterminal">$ty</span>:ident),<span class="kw-2">*</span>) =&gt; (
<a href=#246 id=246 data-nosnippet>246</a> <span class="macro">tuple_trait!</span>(__impl <span class="macro-nonterminal">$name1 $ty1</span>, <span class="macro-nonterminal">$name2 $ty2</span>; $(<span class="macro-nonterminal">$name $ty</span>),<span class="kw-2">*</span>);
<a href=#247 id=247 data-nosnippet>247</a> );
<a href=#248 id=248 data-nosnippet>248</a> (__impl $(<span class="macro-nonterminal">$name</span>:ident <span class="macro-nonterminal">$ty</span>: ident),+; <span class="macro-nonterminal">$name1</span>:ident <span class="macro-nonterminal">$ty1</span>:ident, $(<span class="macro-nonterminal">$name2</span>:ident <span class="macro-nonterminal">$ty2</span>:ident),<span class="kw-2">*</span>) =&gt; (
<a href=#249 id=249 data-nosnippet>249</a> <span class="macro">tuple_trait_impl!</span>($(<span class="macro-nonterminal">$name $ty</span>),+);
<a href=#250 id=250 data-nosnippet>250</a> <span class="macro">tuple_trait!</span>(__impl $(<span class="macro-nonterminal">$name $ty</span>),+ , <span class="macro-nonterminal">$name1 $ty1</span>; $(<span class="macro-nonterminal">$name2 $ty2</span>),<span class="kw-2">*</span>);
<a href=#251 id=251 data-nosnippet>251</a> );
<a href=#252 id=252 data-nosnippet>252</a> (__impl $(<span class="macro-nonterminal">$name</span>:ident <span class="macro-nonterminal">$ty</span>: ident),+; <span class="macro-nonterminal">$name1</span>:ident <span class="macro-nonterminal">$ty1</span>:ident) =&gt; (
<a href=#253 id=253 data-nosnippet>253</a> <span class="macro">tuple_trait_impl!</span>($(<span class="macro-nonterminal">$name $ty</span>),+);
<a href=#254 id=254 data-nosnippet>254</a> <span class="macro">tuple_trait_impl!</span>($(<span class="macro-nonterminal">$name $ty</span>),+, <span class="macro-nonterminal">$name1 $ty1</span>);
<a href=#255 id=255 data-nosnippet>255</a> );
<a href=#256 id=256 data-nosnippet>256</a>);
<a href=#257 id=257 data-nosnippet>257</a>
<a href=#258 id=258 data-nosnippet>258</a><span class="macro">macro_rules!</span> tuple_trait_impl(
<a href=#259 id=259 data-nosnippet>259</a> ($(<span class="macro-nonterminal">$name</span>:ident <span class="macro-nonterminal">$ty</span>: ident),+) =&gt; (
<a href=#260 id=260 data-nosnippet>260</a> <span class="attr">#[allow(deprecated)]
<a href=#261 id=261 data-nosnippet>261</a> </span><span class="kw">impl</span>&lt;
<a href=#262 id=262 data-nosnippet>262</a> Input: Clone, $(<span class="macro-nonterminal">$ty</span>),+ , Error: ParseError&lt;Input&gt;,
<a href=#263 id=263 data-nosnippet>263</a> $(<span class="macro-nonterminal">$name</span>: Parser&lt;Input, Output = <span class="macro-nonterminal">$ty</span>, Error = Error&gt;),+
<a href=#264 id=264 data-nosnippet>264</a> &gt; Tuple&lt;Input, ( $(<span class="macro-nonterminal">$ty</span>),+ ), Error&gt; <span class="kw">for </span>( $(<span class="macro-nonterminal">$name</span>),+ ) {
<a href=#265 id=265 data-nosnippet>265</a> <span class="kw">fn </span>parse_tuple(<span class="kw-2">&amp;mut </span><span class="self">self</span>, input: Input) -&gt; IResult&lt;Input, ( $(<span class="macro-nonterminal">$ty</span>),+ ), Error&gt; {
<a href=#266 id=266 data-nosnippet>266</a> <span class="macro">tuple_trait_inner!</span>(<span class="number">0</span>, <span class="self">self</span>, input, (), $(<span class="macro-nonterminal">$name</span>)+)
<a href=#267 id=267 data-nosnippet>267</a>
<a href=#268 id=268 data-nosnippet>268</a> }
<a href=#269 id=269 data-nosnippet>269</a> }
<a href=#270 id=270 data-nosnippet>270</a> );
<a href=#271 id=271 data-nosnippet>271</a>);
<a href=#272 id=272 data-nosnippet>272</a>
<a href=#273 id=273 data-nosnippet>273</a><span class="macro">macro_rules!</span> tuple_trait_inner(
<a href=#274 id=274 data-nosnippet>274</a> (<span class="macro-nonterminal">$it</span>:tt, <span class="macro-nonterminal">$self</span>:expr, <span class="macro-nonterminal">$input</span>:expr, (), <span class="macro-nonterminal">$head</span>:ident $(<span class="macro-nonterminal">$id</span>:ident)+) =&gt; ({
<a href=#275 id=275 data-nosnippet>275</a> <span class="kw">let </span>(i, o) = <span class="macro-nonterminal">$self</span>.<span class="macro-nonterminal">$it</span>.parse(<span class="macro-nonterminal">$input</span>)<span class="question-mark">?</span>;
<a href=#276 id=276 data-nosnippet>276</a>
<a href=#277 id=277 data-nosnippet>277</a> <span class="macro">succ!</span>(<span class="macro-nonterminal">$it</span>, <span class="macro">tuple_trait_inner!</span>(<span class="macro-nonterminal">$self</span>, i, ( o ), $(<span class="macro-nonterminal">$id</span>)+))
<a href=#278 id=278 data-nosnippet>278</a> });
<a href=#279 id=279 data-nosnippet>279</a> (<span class="macro-nonterminal">$it</span>:tt, <span class="macro-nonterminal">$self</span>:expr, <span class="macro-nonterminal">$input</span>:expr, ($(<span class="macro-nonterminal">$parsed</span>:tt)<span class="kw-2">*</span>), <span class="macro-nonterminal">$head</span>:ident $(<span class="macro-nonterminal">$id</span>:ident)+) =&gt; ({
<a href=#280 id=280 data-nosnippet>280</a> <span class="kw">let </span>(i, o) = <span class="macro-nonterminal">$self</span>.<span class="macro-nonterminal">$it</span>.parse(<span class="macro-nonterminal">$input</span>)<span class="question-mark">?</span>;
<a href=#281 id=281 data-nosnippet>281</a>
<a href=#282 id=282 data-nosnippet>282</a> <span class="macro">succ!</span>(<span class="macro-nonterminal">$it</span>, <span class="macro">tuple_trait_inner!</span>(<span class="macro-nonterminal">$self</span>, i, ($(<span class="macro-nonterminal">$parsed</span>)* , o), $(<span class="macro-nonterminal">$id</span>)+))
<a href=#283 id=283 data-nosnippet>283</a> });
<a href=#284 id=284 data-nosnippet>284</a> (<span class="macro-nonterminal">$it</span>:tt, <span class="macro-nonterminal">$self</span>:expr, <span class="macro-nonterminal">$input</span>:expr, ($(<span class="macro-nonterminal">$parsed</span>:tt)<span class="kw-2">*</span>), <span class="macro-nonterminal">$head</span>:ident) =&gt; ({
<a href=#285 id=285 data-nosnippet>285</a> <span class="kw">let </span>(i, o) = <span class="macro-nonterminal">$self</span>.<span class="macro-nonterminal">$it</span>.parse(<span class="macro-nonterminal">$input</span>)<span class="question-mark">?</span>;
<a href=#286 id=286 data-nosnippet>286</a>
<a href=#287 id=287 data-nosnippet>287</a> <span class="prelude-val">Ok</span>((i, ($(<span class="macro-nonterminal">$parsed</span>)* , o)))
<a href=#288 id=288 data-nosnippet>288</a> });
<a href=#289 id=289 data-nosnippet>289</a>);
<a href=#290 id=290 data-nosnippet>290</a>
<a href=#291 id=291 data-nosnippet>291</a><span class="macro">tuple_trait!</span>(FnA A, FnB B, FnC C, FnD D, FnE E, FnF F, FnG G, FnH H, FnI I, FnJ J, FnK K, FnL L,
<a href=#292 id=292 data-nosnippet>292</a> FnM M, FnN N, FnO O, FnP P, FnQ Q, FnR R, FnS S, FnT T, FnU U);
<a href=#293 id=293 data-nosnippet>293</a>
<a href=#294 id=294 data-nosnippet>294</a><span class="comment">// Special case: implement `Tuple` for `()`, the unit type.
<a href=#295 id=295 data-nosnippet>295</a>// This can come up in macros which accept a variable number of arguments.
<a href=#296 id=296 data-nosnippet>296</a>// Literally, `()` is an empty tuple, so it should simply parse nothing.
<a href=#297 id=297 data-nosnippet>297</a></span><span class="attr">#[allow(deprecated)]
<a href=#298 id=298 data-nosnippet>298</a></span><span class="kw">impl</span>&lt;I, E: ParseError&lt;I&gt;&gt; Tuple&lt;I, (), E&gt; <span class="kw">for </span>() {
<a href=#299 id=299 data-nosnippet>299</a> <span class="kw">fn </span>parse_tuple(<span class="kw-2">&amp;mut </span><span class="self">self</span>, input: I) -&gt; IResult&lt;I, (), E&gt; {
<a href=#300 id=300 data-nosnippet>300</a> <span class="prelude-val">Ok</span>((input, ()))
<a href=#301 id=301 data-nosnippet>301</a> }
<a href=#302 id=302 data-nosnippet>302</a>}
<a href=#303 id=303 data-nosnippet>303</a>
<a href=#304 id=304 data-nosnippet>304</a><span class="doccomment">///Applies a tuple of parsers one by one and returns their results as a tuple.
<a href=#305 id=305 data-nosnippet>305</a>///There is a maximum of 21 parsers
<a href=#306 id=306 data-nosnippet>306</a>/// ```rust
<a href=#307 id=307 data-nosnippet>307</a>/// # use nom::{Err, error::ErrorKind};
<a href=#308 id=308 data-nosnippet>308</a>/// use nom::sequence::tuple;
<a href=#309 id=309 data-nosnippet>309</a>/// use nom::character::complete::{alpha1, digit1};
<a href=#310 id=310 data-nosnippet>310</a>/// let mut parser = tuple((alpha1, digit1, alpha1));
<a href=#311 id=311 data-nosnippet>311</a>///
<a href=#312 id=312 data-nosnippet>312</a>/// assert_eq!(parser("abc123def"), Ok(("", ("abc", "123", "def"))));
<a href=#313 id=313 data-nosnippet>313</a>/// assert_eq!(parser("123def"), Err(Err::Error(("123def", ErrorKind::Alpha))));
<a href=#314 id=314 data-nosnippet>314</a>/// ```
<a href=#315 id=315 data-nosnippet>315</a></span><span class="attr">#[deprecated(since = <span class="string">"8.0.0"</span>, note = <span class="string">"`Parser` is directly implemented for tuples"</span>)]
<a href=#316 id=316 data-nosnippet>316</a>#[allow(deprecated)]
<a href=#317 id=317 data-nosnippet>317</a></span><span class="kw">pub fn </span>tuple&lt;I, O, E: ParseError&lt;I&gt;, List: Tuple&lt;I, O, E&gt;&gt;(
<a href=#318 id=318 data-nosnippet>318</a> <span class="kw-2">mut </span>l: List,
<a href=#319 id=319 data-nosnippet>319</a>) -&gt; <span class="kw">impl </span>FnMut(I) -&gt; IResult&lt;I, O, E&gt; {
<a href=#320 id=320 data-nosnippet>320</a> <span class="kw">move </span>|i: I| l.parse_tuple(i)
<a href=#321 id=321 data-nosnippet>321</a>}
</code></pre></div></section></main></body></html>
+527
View File
@@ -0,0 +1,527 @@
<!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 of the Rust file `/home/newkirk/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/nom-8.0.0/src/str.rs`."><title>str.rs - source</title><script>if(window.location.protocol!=="file:")document.head.insertAdjacentHTML("beforeend","SourceSerif4-Regular-6b053e98.ttf.woff2,FiraSans-Italic-81dc35de.woff2,FiraSans-Regular-0fe48ade.woff2,FiraSans-MediumItalic-ccf7e434.woff2,FiraSans-Medium-e1aa3f0a.woff2,SourceCodePro-Regular-8badfe75.ttf.woff2,SourceCodePro-Semibold-aa29a496.ttf.woff2".split(",").map(f=>`<link rel="preload" as="font" type="font/woff2"href="../../static.files/${f}">`).join(""))</script><link rel="stylesheet" href="../../static.files/normalize-9960930a.css"><link rel="stylesheet" href="../../static.files/rustdoc-ca0dd0c4.css"><meta name="rustdoc-vars" data-root-path="../../" data-static-root-path="../../static.files/" data-current-crate="nom" data-themes="" data-resource-suffix="" data-rustdoc-version="1.93.1 (01f6ddf75 2026-02-11) (Arch Linux rust 1:1.93.1-1)" data-channel="1.93.1" data-search-js="search-9e2438ea.js" data-stringdex-js="stringdex-a3946164.js" data-settings-js="settings-c38705f0.js" ><script src="../../static.files/storage-e2aeef58.js"></script><script defer src="../../static.files/src-script-813739b1.js"></script><script defer src="../../src-files.js"></script><script defer src="../../static.files/main-a410ff4d.js"></script><noscript><link rel="stylesheet" href="../../static.files/noscript-263c88ec.css"></noscript><link rel="alternate icon" type="image/png" href="../../static.files/favicon-32x32-eab170b8.png"><link rel="icon" type="image/svg+xml" href="../../static.files/favicon-044be391.svg"></head><body class="rustdoc src"><!--[if lte IE 11]><div class="warning">This old browser is unsupported and will most likely display funky things.</div><![endif]--><nav class="sidebar"><div class="src-sidebar-title"><h2>Files</h2></div></nav><div class="sidebar-resizer" title="Drag to resize sidebar"></div><main><section id="main-content" class="content"><div class="main-heading"><h1><div class="sub-heading">nom/</div>str.rs</h1><rustdoc-toolbar></rustdoc-toolbar></div><div class="example-wrap digits-3"><pre class="rust"><code><a href=#1 id=1 data-nosnippet>1</a><span class="attr">#[cfg(test)]
<a href=#2 id=2 data-nosnippet>2</a></span><span class="kw">mod </span>test {
<a href=#3 id=3 data-nosnippet>3</a> <span class="attr">#[cfg(feature = <span class="string">"alloc"</span>)]
<a href=#4 id=4 data-nosnippet>4</a> </span><span class="kw">use crate</span>::{branch::alt, bytes::complete::tag_no_case, combinator::recognize, multi::many};
<a href=#5 id=5 data-nosnippet>5</a> <span class="kw">use crate</span>::{
<a href=#6 id=6 data-nosnippet>6</a> bytes::complete::{is_a, is_not, tag, take, take_till, take_until},
<a href=#7 id=7 data-nosnippet>7</a> error::{<span class="self">self</span>, ErrorKind},
<a href=#8 id=8 data-nosnippet>8</a> <span class="prelude-val">Err</span>, IResult,
<a href=#9 id=9 data-nosnippet>9</a> };
<a href=#10 id=10 data-nosnippet>10</a>
<a href=#11 id=11 data-nosnippet>11</a> <span class="attr">#[test]
<a href=#12 id=12 data-nosnippet>12</a> </span><span class="kw">fn </span>tagtr_succeed() {
<a href=#13 id=13 data-nosnippet>13</a> <span class="kw">const </span>INPUT: <span class="kw-2">&amp;</span>str = <span class="string">"Hello World!"</span>;
<a href=#14 id=14 data-nosnippet>14</a> <span class="kw">const </span>TAG: <span class="kw-2">&amp;</span>str = <span class="string">"Hello"</span>;
<a href=#15 id=15 data-nosnippet>15</a> <span class="kw">fn </span>test(input: <span class="kw-2">&amp;</span>str) -&gt; IResult&lt;<span class="kw-2">&amp;</span>str, <span class="kw-2">&amp;</span>str&gt; {
<a href=#16 id=16 data-nosnippet>16</a> tag(TAG)(input)
<a href=#17 id=17 data-nosnippet>17</a> }
<a href=#18 id=18 data-nosnippet>18</a>
<a href=#19 id=19 data-nosnippet>19</a> <span class="kw">match </span>test(INPUT) {
<a href=#20 id=20 data-nosnippet>20</a> <span class="prelude-val">Ok</span>((extra, output)) =&gt; {
<a href=#21 id=21 data-nosnippet>21</a> <span class="macro">assert!</span>(extra == <span class="string">" World!"</span>, <span class="string">"Parser `tag` consumed leftover input."</span>);
<a href=#22 id=22 data-nosnippet>22</a> <span class="macro">assert!</span>(
<a href=#23 id=23 data-nosnippet>23</a> output == TAG,
<a href=#24 id=24 data-nosnippet>24</a> <span class="string">"Parser `tag` doesn't return the tag it matched on success. \
<a href=#25 id=25 data-nosnippet>25</a> Expected `{}`, got `{}`."</span>,
<a href=#26 id=26 data-nosnippet>26</a> TAG,
<a href=#27 id=27 data-nosnippet>27</a> output
<a href=#28 id=28 data-nosnippet>28</a> );
<a href=#29 id=29 data-nosnippet>29</a> }
<a href=#30 id=30 data-nosnippet>30</a> other =&gt; <span class="macro">panic!</span>(
<a href=#31 id=31 data-nosnippet>31</a> <span class="string">"Parser `tag` didn't succeed when it should have. \
<a href=#32 id=32 data-nosnippet>32</a> Got `{:?}`."</span>,
<a href=#33 id=33 data-nosnippet>33</a> other
<a href=#34 id=34 data-nosnippet>34</a> ),
<a href=#35 id=35 data-nosnippet>35</a> };
<a href=#36 id=36 data-nosnippet>36</a> }
<a href=#37 id=37 data-nosnippet>37</a>
<a href=#38 id=38 data-nosnippet>38</a> <span class="attr">#[test]
<a href=#39 id=39 data-nosnippet>39</a> </span><span class="kw">fn </span>tagtr_incomplete() {
<a href=#40 id=40 data-nosnippet>40</a> <span class="kw">use </span><span class="kw">crate</span>::bytes::streaming::tag;
<a href=#41 id=41 data-nosnippet>41</a>
<a href=#42 id=42 data-nosnippet>42</a> <span class="kw">const </span>INPUT: <span class="kw-2">&amp;</span>str = <span class="string">"Hello"</span>;
<a href=#43 id=43 data-nosnippet>43</a> <span class="kw">const </span>TAG: <span class="kw-2">&amp;</span>str = <span class="string">"Hello World!"</span>;
<a href=#44 id=44 data-nosnippet>44</a>
<a href=#45 id=45 data-nosnippet>45</a> <span class="kw">let </span>res: IResult&lt;<span class="kw">_</span>, <span class="kw">_</span>, error::Error&lt;<span class="kw">_</span>&gt;&gt; = tag(TAG)(INPUT);
<a href=#46 id=46 data-nosnippet>46</a> <span class="kw">match </span>res {
<a href=#47 id=47 data-nosnippet>47</a> <span class="prelude-val">Err</span>(Err::Incomplete(<span class="kw">_</span>)) =&gt; (),
<a href=#48 id=48 data-nosnippet>48</a> other =&gt; {
<a href=#49 id=49 data-nosnippet>49</a> <span class="macro">panic!</span>(
<a href=#50 id=50 data-nosnippet>50</a> <span class="string">"Parser `tag` didn't require more input when it should have. \
<a href=#51 id=51 data-nosnippet>51</a> Got `{:?}`."</span>,
<a href=#52 id=52 data-nosnippet>52</a> other
<a href=#53 id=53 data-nosnippet>53</a> );
<a href=#54 id=54 data-nosnippet>54</a> }
<a href=#55 id=55 data-nosnippet>55</a> };
<a href=#56 id=56 data-nosnippet>56</a> }
<a href=#57 id=57 data-nosnippet>57</a>
<a href=#58 id=58 data-nosnippet>58</a> <span class="attr">#[test]
<a href=#59 id=59 data-nosnippet>59</a> </span><span class="kw">fn </span>tagtr_error() {
<a href=#60 id=60 data-nosnippet>60</a> <span class="kw">const </span>INPUT: <span class="kw-2">&amp;</span>str = <span class="string">"Hello World!"</span>;
<a href=#61 id=61 data-nosnippet>61</a> <span class="kw">const </span>TAG: <span class="kw-2">&amp;</span>str = <span class="string">"Random"</span>; <span class="comment">// TAG must be closer than INPUT.
<a href=#62 id=62 data-nosnippet>62</a>
<a href=#63 id=63 data-nosnippet>63</a> </span><span class="kw">let </span>res: IResult&lt;<span class="kw">_</span>, <span class="kw">_</span>, error::Error&lt;<span class="kw">_</span>&gt;&gt; = tag(TAG)(INPUT);
<a href=#64 id=64 data-nosnippet>64</a> <span class="kw">match </span>res {
<a href=#65 id=65 data-nosnippet>65</a> <span class="prelude-val">Err</span>(Err::Error(<span class="kw">_</span>)) =&gt; (),
<a href=#66 id=66 data-nosnippet>66</a> other =&gt; {
<a href=#67 id=67 data-nosnippet>67</a> <span class="macro">panic!</span>(
<a href=#68 id=68 data-nosnippet>68</a> <span class="string">"Parser `tag` didn't fail when it should have. Got `{:?}`.`"</span>,
<a href=#69 id=69 data-nosnippet>69</a> other
<a href=#70 id=70 data-nosnippet>70</a> );
<a href=#71 id=71 data-nosnippet>71</a> }
<a href=#72 id=72 data-nosnippet>72</a> };
<a href=#73 id=73 data-nosnippet>73</a> }
<a href=#74 id=74 data-nosnippet>74</a>
<a href=#75 id=75 data-nosnippet>75</a> <span class="attr">#[test]
<a href=#76 id=76 data-nosnippet>76</a> </span><span class="kw">fn </span>take_s_succeed() {
<a href=#77 id=77 data-nosnippet>77</a> <span class="kw">const </span>INPUT: <span class="kw-2">&amp;</span>str = <span class="string">"βèƒôřèÂßÇáƒƭèř"</span>;
<a href=#78 id=78 data-nosnippet>78</a> <span class="kw">const </span>CONSUMED: <span class="kw-2">&amp;</span>str = <span class="string">"βèƒôřèÂßÇ"</span>;
<a href=#79 id=79 data-nosnippet>79</a> <span class="kw">const </span>LEFTOVER: <span class="kw-2">&amp;</span>str = <span class="string">"áƒƭèř"</span>;
<a href=#80 id=80 data-nosnippet>80</a>
<a href=#81 id=81 data-nosnippet>81</a> <span class="kw">let </span>res: IResult&lt;<span class="kw">_</span>, <span class="kw">_</span>, error::Error&lt;<span class="kw">_</span>&gt;&gt; = take(<span class="number">9_usize</span>)(INPUT);
<a href=#82 id=82 data-nosnippet>82</a> <span class="kw">match </span>res {
<a href=#83 id=83 data-nosnippet>83</a> <span class="prelude-val">Ok</span>((extra, output)) =&gt; {
<a href=#84 id=84 data-nosnippet>84</a> <span class="macro">assert!</span>(
<a href=#85 id=85 data-nosnippet>85</a> extra == LEFTOVER,
<a href=#86 id=86 data-nosnippet>86</a> <span class="string">"Parser `take_s` consumed leftover input. Leftover `{}`."</span>,
<a href=#87 id=87 data-nosnippet>87</a> extra
<a href=#88 id=88 data-nosnippet>88</a> );
<a href=#89 id=89 data-nosnippet>89</a> <span class="macro">assert!</span>(
<a href=#90 id=90 data-nosnippet>90</a> output == CONSUMED,
<a href=#91 id=91 data-nosnippet>91</a> <span class="string">"Parser `take_s` doesn't return the string it consumed on success. Expected `{}`, got `{}`."</span>,
<a href=#92 id=92 data-nosnippet>92</a> CONSUMED,
<a href=#93 id=93 data-nosnippet>93</a> output
<a href=#94 id=94 data-nosnippet>94</a> );
<a href=#95 id=95 data-nosnippet>95</a> }
<a href=#96 id=96 data-nosnippet>96</a> other =&gt; <span class="macro">panic!</span>(
<a href=#97 id=97 data-nosnippet>97</a> <span class="string">"Parser `take_s` didn't succeed when it should have. \
<a href=#98 id=98 data-nosnippet>98</a> Got `{:?}`."</span>,
<a href=#99 id=99 data-nosnippet>99</a> other
<a href=#100 id=100 data-nosnippet>100</a> ),
<a href=#101 id=101 data-nosnippet>101</a> };
<a href=#102 id=102 data-nosnippet>102</a> }
<a href=#103 id=103 data-nosnippet>103</a>
<a href=#104 id=104 data-nosnippet>104</a> <span class="attr">#[test]
<a href=#105 id=105 data-nosnippet>105</a> </span><span class="kw">fn </span>take_until_succeed() {
<a href=#106 id=106 data-nosnippet>106</a> <span class="kw">const </span>INPUT: <span class="kw-2">&amp;</span>str = <span class="string">"βèƒôřèÂßÇ∂áƒƭèř"</span>;
<a href=#107 id=107 data-nosnippet>107</a> <span class="kw">const </span>FIND: <span class="kw-2">&amp;</span>str = <span class="string">"ÂßÇ∂"</span>;
<a href=#108 id=108 data-nosnippet>108</a> <span class="kw">const </span>CONSUMED: <span class="kw-2">&amp;</span>str = <span class="string">"βèƒôřè"</span>;
<a href=#109 id=109 data-nosnippet>109</a> <span class="kw">const </span>LEFTOVER: <span class="kw-2">&amp;</span>str = <span class="string">"ÂßÇ∂áƒƭèř"</span>;
<a href=#110 id=110 data-nosnippet>110</a>
<a href=#111 id=111 data-nosnippet>111</a> <span class="kw">let </span>res: IResult&lt;<span class="kw">_</span>, <span class="kw">_</span>, (<span class="kw">_</span>, ErrorKind)&gt; = take_until(FIND)(INPUT);
<a href=#112 id=112 data-nosnippet>112</a> <span class="kw">match </span>res {
<a href=#113 id=113 data-nosnippet>113</a> <span class="prelude-val">Ok</span>((extra, output)) =&gt; {
<a href=#114 id=114 data-nosnippet>114</a> <span class="macro">assert!</span>(
<a href=#115 id=115 data-nosnippet>115</a> extra == LEFTOVER,
<a href=#116 id=116 data-nosnippet>116</a> <span class="string">"Parser `take_until`\
<a href=#117 id=117 data-nosnippet>117</a> consumed leftover input. Leftover `{}`."</span>,
<a href=#118 id=118 data-nosnippet>118</a> extra
<a href=#119 id=119 data-nosnippet>119</a> );
<a href=#120 id=120 data-nosnippet>120</a> <span class="macro">assert!</span>(
<a href=#121 id=121 data-nosnippet>121</a> output == CONSUMED,
<a href=#122 id=122 data-nosnippet>122</a> <span class="string">"Parser `take_until`\
<a href=#123 id=123 data-nosnippet>123</a> doesn't return the string it consumed on success. Expected `{}`, got `{}`."</span>,
<a href=#124 id=124 data-nosnippet>124</a> CONSUMED,
<a href=#125 id=125 data-nosnippet>125</a> output
<a href=#126 id=126 data-nosnippet>126</a> );
<a href=#127 id=127 data-nosnippet>127</a> }
<a href=#128 id=128 data-nosnippet>128</a> other =&gt; <span class="macro">panic!</span>(
<a href=#129 id=129 data-nosnippet>129</a> <span class="string">"Parser `take_until` didn't succeed when it should have. \
<a href=#130 id=130 data-nosnippet>130</a> Got `{:?}`."</span>,
<a href=#131 id=131 data-nosnippet>131</a> other
<a href=#132 id=132 data-nosnippet>132</a> ),
<a href=#133 id=133 data-nosnippet>133</a> };
<a href=#134 id=134 data-nosnippet>134</a> }
<a href=#135 id=135 data-nosnippet>135</a>
<a href=#136 id=136 data-nosnippet>136</a> <span class="attr">#[test]
<a href=#137 id=137 data-nosnippet>137</a> </span><span class="kw">fn </span>take_s_incomplete() {
<a href=#138 id=138 data-nosnippet>138</a> <span class="kw">use </span><span class="kw">crate</span>::bytes::streaming::take;
<a href=#139 id=139 data-nosnippet>139</a>
<a href=#140 id=140 data-nosnippet>140</a> <span class="kw">const </span>INPUT: <span class="kw-2">&amp;</span>str = <span class="string">"βèƒôřèÂßÇá"</span>;
<a href=#141 id=141 data-nosnippet>141</a>
<a href=#142 id=142 data-nosnippet>142</a> <span class="kw">let </span>res: IResult&lt;<span class="kw">_</span>, <span class="kw">_</span>, (<span class="kw">_</span>, ErrorKind)&gt; = take(<span class="number">13_usize</span>)(INPUT);
<a href=#143 id=143 data-nosnippet>143</a> <span class="kw">match </span>res {
<a href=#144 id=144 data-nosnippet>144</a> <span class="prelude-val">Err</span>(Err::Incomplete(<span class="kw">_</span>)) =&gt; (),
<a href=#145 id=145 data-nosnippet>145</a> other =&gt; <span class="macro">panic!</span>(
<a href=#146 id=146 data-nosnippet>146</a> <span class="string">"Parser `take` didn't require more input when it should have. \
<a href=#147 id=147 data-nosnippet>147</a> Got `{:?}`."</span>,
<a href=#148 id=148 data-nosnippet>148</a> other
<a href=#149 id=149 data-nosnippet>149</a> ),
<a href=#150 id=150 data-nosnippet>150</a> }
<a href=#151 id=151 data-nosnippet>151</a> }
<a href=#152 id=152 data-nosnippet>152</a>
<a href=#153 id=153 data-nosnippet>153</a> <span class="kw">use </span><span class="kw">crate</span>::internal::Needed;
<a href=#154 id=154 data-nosnippet>154</a>
<a href=#155 id=155 data-nosnippet>155</a> <span class="kw">fn </span>is_alphabetic(c: char) -&gt; bool {
<a href=#156 id=156 data-nosnippet>156</a> (c <span class="kw">as </span>u8 &gt;= <span class="number">0x41 </span>&amp;&amp; c <span class="kw">as </span>u8 &lt;= <span class="number">0x5A</span>) || (c <span class="kw">as </span>u8 &gt;= <span class="number">0x61 </span>&amp;&amp; c <span class="kw">as </span>u8 &lt;= <span class="number">0x7A</span>)
<a href=#157 id=157 data-nosnippet>157</a> }
<a href=#158 id=158 data-nosnippet>158</a>
<a href=#159 id=159 data-nosnippet>159</a> <span class="attr">#[test]
<a href=#160 id=160 data-nosnippet>160</a> </span><span class="kw">fn </span>take_while() {
<a href=#161 id=161 data-nosnippet>161</a> <span class="kw">use </span><span class="kw">crate</span>::bytes::streaming::take_while;
<a href=#162 id=162 data-nosnippet>162</a>
<a href=#163 id=163 data-nosnippet>163</a> <span class="kw">fn </span>f(i: <span class="kw-2">&amp;</span>str) -&gt; IResult&lt;<span class="kw-2">&amp;</span>str, <span class="kw-2">&amp;</span>str&gt; {
<a href=#164 id=164 data-nosnippet>164</a> take_while(is_alphabetic)(i)
<a href=#165 id=165 data-nosnippet>165</a> }
<a href=#166 id=166 data-nosnippet>166</a> <span class="kw">let </span>a = <span class="string">""</span>;
<a href=#167 id=167 data-nosnippet>167</a> <span class="kw">let </span>b = <span class="string">"abcd"</span>;
<a href=#168 id=168 data-nosnippet>168</a> <span class="kw">let </span>c = <span class="string">"abcd123"</span>;
<a href=#169 id=169 data-nosnippet>169</a> <span class="kw">let </span>d = <span class="string">"123"</span>;
<a href=#170 id=170 data-nosnippet>170</a>
<a href=#171 id=171 data-nosnippet>171</a> <span class="macro">assert_eq!</span>(f(a), <span class="prelude-val">Err</span>(Err::Incomplete(Needed::new(<span class="number">1</span>))));
<a href=#172 id=172 data-nosnippet>172</a> <span class="macro">assert_eq!</span>(f(b), <span class="prelude-val">Err</span>(Err::Incomplete(Needed::new(<span class="number">1</span>))));
<a href=#173 id=173 data-nosnippet>173</a> <span class="macro">assert_eq!</span>(f(c), <span class="prelude-val">Ok</span>((d, b)));
<a href=#174 id=174 data-nosnippet>174</a> <span class="macro">assert_eq!</span>(f(d), <span class="prelude-val">Ok</span>((d, a)));
<a href=#175 id=175 data-nosnippet>175</a> }
<a href=#176 id=176 data-nosnippet>176</a>
<a href=#177 id=177 data-nosnippet>177</a> <span class="attr">#[test]
<a href=#178 id=178 data-nosnippet>178</a> </span><span class="kw">fn </span>take_while1() {
<a href=#179 id=179 data-nosnippet>179</a> <span class="kw">use </span><span class="kw">crate</span>::bytes::streaming::take_while1;
<a href=#180 id=180 data-nosnippet>180</a>
<a href=#181 id=181 data-nosnippet>181</a> <span class="kw">fn </span>f(i: <span class="kw-2">&amp;</span>str) -&gt; IResult&lt;<span class="kw-2">&amp;</span>str, <span class="kw-2">&amp;</span>str&gt; {
<a href=#182 id=182 data-nosnippet>182</a> take_while1(is_alphabetic)(i)
<a href=#183 id=183 data-nosnippet>183</a> }
<a href=#184 id=184 data-nosnippet>184</a> <span class="kw">let </span>a = <span class="string">""</span>;
<a href=#185 id=185 data-nosnippet>185</a> <span class="kw">let </span>b = <span class="string">"abcd"</span>;
<a href=#186 id=186 data-nosnippet>186</a> <span class="kw">let </span>c = <span class="string">"abcd123"</span>;
<a href=#187 id=187 data-nosnippet>187</a> <span class="kw">let </span>d = <span class="string">"123"</span>;
<a href=#188 id=188 data-nosnippet>188</a>
<a href=#189 id=189 data-nosnippet>189</a> <span class="macro">assert_eq!</span>(f(a), <span class="prelude-val">Err</span>(Err::Incomplete(Needed::new(<span class="number">1</span>))));
<a href=#190 id=190 data-nosnippet>190</a> <span class="macro">assert_eq!</span>(f(b), <span class="prelude-val">Err</span>(Err::Incomplete(Needed::new(<span class="number">1</span>))));
<a href=#191 id=191 data-nosnippet>191</a> <span class="macro">assert_eq!</span>(f(c), <span class="prelude-val">Ok</span>((<span class="string">"123"</span>, b)));
<a href=#192 id=192 data-nosnippet>192</a> <span class="macro">assert_eq!</span>(
<a href=#193 id=193 data-nosnippet>193</a> f(d),
<a href=#194 id=194 data-nosnippet>194</a> <span class="prelude-val">Err</span>(Err::Error(<span class="macro">error_position!</span>(d, ErrorKind::TakeWhile1)))
<a href=#195 id=195 data-nosnippet>195</a> );
<a href=#196 id=196 data-nosnippet>196</a> }
<a href=#197 id=197 data-nosnippet>197</a>
<a href=#198 id=198 data-nosnippet>198</a> <span class="attr">#[test]
<a href=#199 id=199 data-nosnippet>199</a> </span><span class="kw">fn </span>take_till_s_succeed() {
<a href=#200 id=200 data-nosnippet>200</a> <span class="kw">const </span>INPUT: <span class="kw-2">&amp;</span>str = <span class="string">"βèƒôřèÂßÇáƒƭèř"</span>;
<a href=#201 id=201 data-nosnippet>201</a> <span class="kw">const </span>CONSUMED: <span class="kw-2">&amp;</span>str = <span class="string">"βèƒôřèÂßÇ"</span>;
<a href=#202 id=202 data-nosnippet>202</a> <span class="kw">const </span>LEFTOVER: <span class="kw-2">&amp;</span>str = <span class="string">"áƒƭèř"</span>;
<a href=#203 id=203 data-nosnippet>203</a> <span class="kw">fn </span>till_s(c: char) -&gt; bool {
<a href=#204 id=204 data-nosnippet>204</a> c == <span class="string">'á'
<a href=#205 id=205 data-nosnippet>205</a> </span>}
<a href=#206 id=206 data-nosnippet>206</a> <span class="kw">fn </span>test(input: <span class="kw-2">&amp;</span>str) -&gt; IResult&lt;<span class="kw-2">&amp;</span>str, <span class="kw-2">&amp;</span>str&gt; {
<a href=#207 id=207 data-nosnippet>207</a> take_till(till_s)(input)
<a href=#208 id=208 data-nosnippet>208</a> }
<a href=#209 id=209 data-nosnippet>209</a> <span class="kw">match </span>test(INPUT) {
<a href=#210 id=210 data-nosnippet>210</a> <span class="prelude-val">Ok</span>((extra, output)) =&gt; {
<a href=#211 id=211 data-nosnippet>211</a> <span class="macro">assert!</span>(
<a href=#212 id=212 data-nosnippet>212</a> extra == LEFTOVER,
<a href=#213 id=213 data-nosnippet>213</a> <span class="string">"Parser `take_till` consumed leftover input."
<a href=#214 id=214 data-nosnippet>214</a> </span>);
<a href=#215 id=215 data-nosnippet>215</a> <span class="macro">assert!</span>(
<a href=#216 id=216 data-nosnippet>216</a> output == CONSUMED,
<a href=#217 id=217 data-nosnippet>217</a> <span class="string">"Parser `take_till` doesn't return the string it consumed on success. \
<a href=#218 id=218 data-nosnippet>218</a> Expected `{}`, got `{}`."</span>,
<a href=#219 id=219 data-nosnippet>219</a> CONSUMED,
<a href=#220 id=220 data-nosnippet>220</a> output
<a href=#221 id=221 data-nosnippet>221</a> );
<a href=#222 id=222 data-nosnippet>222</a> }
<a href=#223 id=223 data-nosnippet>223</a> other =&gt; <span class="macro">panic!</span>(
<a href=#224 id=224 data-nosnippet>224</a> <span class="string">"Parser `take_till` didn't succeed when it should have. \
<a href=#225 id=225 data-nosnippet>225</a> Got `{:?}`."</span>,
<a href=#226 id=226 data-nosnippet>226</a> other
<a href=#227 id=227 data-nosnippet>227</a> ),
<a href=#228 id=228 data-nosnippet>228</a> };
<a href=#229 id=229 data-nosnippet>229</a> }
<a href=#230 id=230 data-nosnippet>230</a>
<a href=#231 id=231 data-nosnippet>231</a> <span class="attr">#[test]
<a href=#232 id=232 data-nosnippet>232</a> </span><span class="kw">fn </span>take_while_succeed_none() {
<a href=#233 id=233 data-nosnippet>233</a> <span class="kw">use </span><span class="kw">crate</span>::bytes::complete::take_while;
<a href=#234 id=234 data-nosnippet>234</a>
<a href=#235 id=235 data-nosnippet>235</a> <span class="kw">const </span>INPUT: <span class="kw-2">&amp;</span>str = <span class="string">"βèƒôřèÂßÇáƒƭèř"</span>;
<a href=#236 id=236 data-nosnippet>236</a> <span class="kw">const </span>CONSUMED: <span class="kw-2">&amp;</span>str = <span class="string">""</span>;
<a href=#237 id=237 data-nosnippet>237</a> <span class="kw">const </span>LEFTOVER: <span class="kw-2">&amp;</span>str = <span class="string">"βèƒôřèÂßÇáƒƭèř"</span>;
<a href=#238 id=238 data-nosnippet>238</a> <span class="kw">fn </span>while_s(c: char) -&gt; bool {
<a href=#239 id=239 data-nosnippet>239</a> c == <span class="string">'9'
<a href=#240 id=240 data-nosnippet>240</a> </span>}
<a href=#241 id=241 data-nosnippet>241</a> <span class="kw">fn </span>test(input: <span class="kw-2">&amp;</span>str) -&gt; IResult&lt;<span class="kw-2">&amp;</span>str, <span class="kw-2">&amp;</span>str&gt; {
<a href=#242 id=242 data-nosnippet>242</a> take_while(while_s)(input)
<a href=#243 id=243 data-nosnippet>243</a> }
<a href=#244 id=244 data-nosnippet>244</a> <span class="kw">match </span>test(INPUT) {
<a href=#245 id=245 data-nosnippet>245</a> <span class="prelude-val">Ok</span>((extra, output)) =&gt; {
<a href=#246 id=246 data-nosnippet>246</a> <span class="macro">assert!</span>(
<a href=#247 id=247 data-nosnippet>247</a> extra == LEFTOVER,
<a href=#248 id=248 data-nosnippet>248</a> <span class="string">"Parser `take_while` consumed leftover input."
<a href=#249 id=249 data-nosnippet>249</a> </span>);
<a href=#250 id=250 data-nosnippet>250</a> <span class="macro">assert!</span>(
<a href=#251 id=251 data-nosnippet>251</a> output == CONSUMED,
<a href=#252 id=252 data-nosnippet>252</a> <span class="string">"Parser `take_while` doesn't return the string it consumed on success. \
<a href=#253 id=253 data-nosnippet>253</a> Expected `{}`, got `{}`."</span>,
<a href=#254 id=254 data-nosnippet>254</a> CONSUMED,
<a href=#255 id=255 data-nosnippet>255</a> output
<a href=#256 id=256 data-nosnippet>256</a> );
<a href=#257 id=257 data-nosnippet>257</a> }
<a href=#258 id=258 data-nosnippet>258</a> other =&gt; <span class="macro">panic!</span>(
<a href=#259 id=259 data-nosnippet>259</a> <span class="string">"Parser `take_while` didn't succeed when it should have. \
<a href=#260 id=260 data-nosnippet>260</a> Got `{:?}`."</span>,
<a href=#261 id=261 data-nosnippet>261</a> other
<a href=#262 id=262 data-nosnippet>262</a> ),
<a href=#263 id=263 data-nosnippet>263</a> };
<a href=#264 id=264 data-nosnippet>264</a> }
<a href=#265 id=265 data-nosnippet>265</a>
<a href=#266 id=266 data-nosnippet>266</a> <span class="attr">#[test]
<a href=#267 id=267 data-nosnippet>267</a> </span><span class="kw">fn </span>is_not_succeed() {
<a href=#268 id=268 data-nosnippet>268</a> <span class="kw">const </span>INPUT: <span class="kw-2">&amp;</span>str = <span class="string">"βèƒôřèÂßÇáƒƭèř"</span>;
<a href=#269 id=269 data-nosnippet>269</a> <span class="kw">const </span>AVOID: <span class="kw-2">&amp;</span>str = <span class="string">"£úçƙ¥á"</span>;
<a href=#270 id=270 data-nosnippet>270</a> <span class="kw">const </span>CONSUMED: <span class="kw-2">&amp;</span>str = <span class="string">"βèƒôřèÂßÇ"</span>;
<a href=#271 id=271 data-nosnippet>271</a> <span class="kw">const </span>LEFTOVER: <span class="kw-2">&amp;</span>str = <span class="string">"áƒƭèř"</span>;
<a href=#272 id=272 data-nosnippet>272</a> <span class="kw">fn </span>test(input: <span class="kw-2">&amp;</span>str) -&gt; IResult&lt;<span class="kw-2">&amp;</span>str, <span class="kw-2">&amp;</span>str&gt; {
<a href=#273 id=273 data-nosnippet>273</a> is_not(AVOID)(input)
<a href=#274 id=274 data-nosnippet>274</a> }
<a href=#275 id=275 data-nosnippet>275</a> <span class="kw">match </span>test(INPUT) {
<a href=#276 id=276 data-nosnippet>276</a> <span class="prelude-val">Ok</span>((extra, output)) =&gt; {
<a href=#277 id=277 data-nosnippet>277</a> <span class="macro">assert!</span>(
<a href=#278 id=278 data-nosnippet>278</a> extra == LEFTOVER,
<a href=#279 id=279 data-nosnippet>279</a> <span class="string">"Parser `is_not` consumed leftover input. Leftover `{}`."</span>,
<a href=#280 id=280 data-nosnippet>280</a> extra
<a href=#281 id=281 data-nosnippet>281</a> );
<a href=#282 id=282 data-nosnippet>282</a> <span class="macro">assert!</span>(
<a href=#283 id=283 data-nosnippet>283</a> output == CONSUMED,
<a href=#284 id=284 data-nosnippet>284</a> <span class="string">"Parser `is_not` doesn't return the string it consumed on success. Expected `{}`, got `{}`."</span>,
<a href=#285 id=285 data-nosnippet>285</a> CONSUMED,
<a href=#286 id=286 data-nosnippet>286</a> output
<a href=#287 id=287 data-nosnippet>287</a> );
<a href=#288 id=288 data-nosnippet>288</a> }
<a href=#289 id=289 data-nosnippet>289</a> other =&gt; <span class="macro">panic!</span>(
<a href=#290 id=290 data-nosnippet>290</a> <span class="string">"Parser `is_not` didn't succeed when it should have. \
<a href=#291 id=291 data-nosnippet>291</a> Got `{:?}`."</span>,
<a href=#292 id=292 data-nosnippet>292</a> other
<a href=#293 id=293 data-nosnippet>293</a> ),
<a href=#294 id=294 data-nosnippet>294</a> };
<a href=#295 id=295 data-nosnippet>295</a> }
<a href=#296 id=296 data-nosnippet>296</a>
<a href=#297 id=297 data-nosnippet>297</a> <span class="attr">#[test]
<a href=#298 id=298 data-nosnippet>298</a> </span><span class="kw">fn </span>take_while_succeed_some() {
<a href=#299 id=299 data-nosnippet>299</a> <span class="kw">use </span><span class="kw">crate</span>::bytes::complete::take_while;
<a href=#300 id=300 data-nosnippet>300</a>
<a href=#301 id=301 data-nosnippet>301</a> <span class="kw">const </span>INPUT: <span class="kw-2">&amp;</span>str = <span class="string">"βèƒôřèÂßÇáƒƭèř"</span>;
<a href=#302 id=302 data-nosnippet>302</a> <span class="kw">const </span>CONSUMED: <span class="kw-2">&amp;</span>str = <span class="string">"βèƒôřèÂßÇ"</span>;
<a href=#303 id=303 data-nosnippet>303</a> <span class="kw">const </span>LEFTOVER: <span class="kw-2">&amp;</span>str = <span class="string">"áƒƭèř"</span>;
<a href=#304 id=304 data-nosnippet>304</a> <span class="kw">fn </span>while_s(c: char) -&gt; bool {
<a href=#305 id=305 data-nosnippet>305</a> <span class="macro">matches!</span>(c, <span class="string">'β' </span>| <span class="string">'è' </span>| <span class="string">'ƒ' </span>| <span class="string">'ô' </span>| <span class="string">'ř' </span>| <span class="string">'Â' </span>| <span class="string">'ß' </span>| <span class="string">'Ç'</span>)
<a href=#306 id=306 data-nosnippet>306</a> }
<a href=#307 id=307 data-nosnippet>307</a> <span class="kw">fn </span>test(input: <span class="kw-2">&amp;</span>str) -&gt; IResult&lt;<span class="kw-2">&amp;</span>str, <span class="kw-2">&amp;</span>str&gt; {
<a href=#308 id=308 data-nosnippet>308</a> take_while(while_s)(input)
<a href=#309 id=309 data-nosnippet>309</a> }
<a href=#310 id=310 data-nosnippet>310</a> <span class="kw">match </span>test(INPUT) {
<a href=#311 id=311 data-nosnippet>311</a> <span class="prelude-val">Ok</span>((extra, output)) =&gt; {
<a href=#312 id=312 data-nosnippet>312</a> <span class="macro">assert!</span>(
<a href=#313 id=313 data-nosnippet>313</a> extra == LEFTOVER,
<a href=#314 id=314 data-nosnippet>314</a> <span class="string">"Parser `take_while` consumed leftover input."
<a href=#315 id=315 data-nosnippet>315</a> </span>);
<a href=#316 id=316 data-nosnippet>316</a> <span class="macro">assert!</span>(
<a href=#317 id=317 data-nosnippet>317</a> output == CONSUMED,
<a href=#318 id=318 data-nosnippet>318</a> <span class="string">"Parser `take_while` doesn't return the string it consumed on success. \
<a href=#319 id=319 data-nosnippet>319</a> Expected `{}`, got `{}`."</span>,
<a href=#320 id=320 data-nosnippet>320</a> CONSUMED,
<a href=#321 id=321 data-nosnippet>321</a> output
<a href=#322 id=322 data-nosnippet>322</a> );
<a href=#323 id=323 data-nosnippet>323</a> }
<a href=#324 id=324 data-nosnippet>324</a> other =&gt; <span class="macro">panic!</span>(
<a href=#325 id=325 data-nosnippet>325</a> <span class="string">"Parser `take_while` didn't succeed when it should have. \
<a href=#326 id=326 data-nosnippet>326</a> Got `{:?}`."</span>,
<a href=#327 id=327 data-nosnippet>327</a> other
<a href=#328 id=328 data-nosnippet>328</a> ),
<a href=#329 id=329 data-nosnippet>329</a> };
<a href=#330 id=330 data-nosnippet>330</a> }
<a href=#331 id=331 data-nosnippet>331</a>
<a href=#332 id=332 data-nosnippet>332</a> <span class="attr">#[test]
<a href=#333 id=333 data-nosnippet>333</a> </span><span class="kw">fn </span>is_not_fail() {
<a href=#334 id=334 data-nosnippet>334</a> <span class="kw">const </span>INPUT: <span class="kw-2">&amp;</span>str = <span class="string">"βèƒôřèÂßÇáƒƭèř"</span>;
<a href=#335 id=335 data-nosnippet>335</a> <span class="kw">const </span>AVOID: <span class="kw-2">&amp;</span>str = <span class="string">"βúçƙ¥"</span>;
<a href=#336 id=336 data-nosnippet>336</a> <span class="kw">fn </span>test(input: <span class="kw-2">&amp;</span>str) -&gt; IResult&lt;<span class="kw-2">&amp;</span>str, <span class="kw-2">&amp;</span>str&gt; {
<a href=#337 id=337 data-nosnippet>337</a> is_not(AVOID)(input)
<a href=#338 id=338 data-nosnippet>338</a> }
<a href=#339 id=339 data-nosnippet>339</a> <span class="kw">match </span>test(INPUT) {
<a href=#340 id=340 data-nosnippet>340</a> <span class="prelude-val">Err</span>(Err::Error(<span class="kw">_</span>)) =&gt; (),
<a href=#341 id=341 data-nosnippet>341</a> other =&gt; <span class="macro">panic!</span>(
<a href=#342 id=342 data-nosnippet>342</a> <span class="string">"Parser `is_not` didn't fail when it should have. Got `{:?}`."</span>,
<a href=#343 id=343 data-nosnippet>343</a> other
<a href=#344 id=344 data-nosnippet>344</a> ),
<a href=#345 id=345 data-nosnippet>345</a> };
<a href=#346 id=346 data-nosnippet>346</a> }
<a href=#347 id=347 data-nosnippet>347</a>
<a href=#348 id=348 data-nosnippet>348</a> <span class="attr">#[test]
<a href=#349 id=349 data-nosnippet>349</a> </span><span class="kw">fn </span>take_while1_succeed() {
<a href=#350 id=350 data-nosnippet>350</a> <span class="kw">use </span><span class="kw">crate</span>::bytes::complete::take_while1;
<a href=#351 id=351 data-nosnippet>351</a>
<a href=#352 id=352 data-nosnippet>352</a> <span class="kw">const </span>INPUT: <span class="kw-2">&amp;</span>str = <span class="string">"βèƒôřèÂßÇáƒƭèř"</span>;
<a href=#353 id=353 data-nosnippet>353</a> <span class="kw">const </span>CONSUMED: <span class="kw-2">&amp;</span>str = <span class="string">"βèƒôřèÂßÇ"</span>;
<a href=#354 id=354 data-nosnippet>354</a> <span class="kw">const </span>LEFTOVER: <span class="kw-2">&amp;</span>str = <span class="string">"áƒƭèř"</span>;
<a href=#355 id=355 data-nosnippet>355</a> <span class="kw">fn </span>while1_s(c: char) -&gt; bool {
<a href=#356 id=356 data-nosnippet>356</a> <span class="macro">matches!</span>(c, <span class="string">'β' </span>| <span class="string">'è' </span>| <span class="string">'ƒ' </span>| <span class="string">'ô' </span>| <span class="string">'ř' </span>| <span class="string">'Â' </span>| <span class="string">'ß' </span>| <span class="string">'Ç'</span>)
<a href=#357 id=357 data-nosnippet>357</a> }
<a href=#358 id=358 data-nosnippet>358</a> <span class="kw">fn </span>test(input: <span class="kw-2">&amp;</span>str) -&gt; IResult&lt;<span class="kw-2">&amp;</span>str, <span class="kw-2">&amp;</span>str&gt; {
<a href=#359 id=359 data-nosnippet>359</a> take_while1(while1_s)(input)
<a href=#360 id=360 data-nosnippet>360</a> }
<a href=#361 id=361 data-nosnippet>361</a> <span class="kw">match </span>test(INPUT) {
<a href=#362 id=362 data-nosnippet>362</a> <span class="prelude-val">Ok</span>((extra, output)) =&gt; {
<a href=#363 id=363 data-nosnippet>363</a> <span class="macro">assert!</span>(
<a href=#364 id=364 data-nosnippet>364</a> extra == LEFTOVER,
<a href=#365 id=365 data-nosnippet>365</a> <span class="string">"Parser `take_while1` consumed leftover input."
<a href=#366 id=366 data-nosnippet>366</a> </span>);
<a href=#367 id=367 data-nosnippet>367</a> <span class="macro">assert!</span>(
<a href=#368 id=368 data-nosnippet>368</a> output == CONSUMED,
<a href=#369 id=369 data-nosnippet>369</a> <span class="string">"Parser `take_while1` doesn't return the string it consumed on success. \
<a href=#370 id=370 data-nosnippet>370</a> Expected `{}`, got `{}`."</span>,
<a href=#371 id=371 data-nosnippet>371</a> CONSUMED,
<a href=#372 id=372 data-nosnippet>372</a> output
<a href=#373 id=373 data-nosnippet>373</a> );
<a href=#374 id=374 data-nosnippet>374</a> }
<a href=#375 id=375 data-nosnippet>375</a> other =&gt; <span class="macro">panic!</span>(
<a href=#376 id=376 data-nosnippet>376</a> <span class="string">"Parser `take_while1` didn't succeed when it should have. \
<a href=#377 id=377 data-nosnippet>377</a> Got `{:?}`."</span>,
<a href=#378 id=378 data-nosnippet>378</a> other
<a href=#379 id=379 data-nosnippet>379</a> ),
<a href=#380 id=380 data-nosnippet>380</a> };
<a href=#381 id=381 data-nosnippet>381</a> }
<a href=#382 id=382 data-nosnippet>382</a>
<a href=#383 id=383 data-nosnippet>383</a> <span class="attr">#[test]
<a href=#384 id=384 data-nosnippet>384</a> </span><span class="kw">fn </span>take_until_incomplete() {
<a href=#385 id=385 data-nosnippet>385</a> <span class="kw">use </span><span class="kw">crate</span>::bytes::streaming::take_until;
<a href=#386 id=386 data-nosnippet>386</a>
<a href=#387 id=387 data-nosnippet>387</a> <span class="kw">const </span>INPUT: <span class="kw-2">&amp;</span>str = <span class="string">"βèƒôřè"</span>;
<a href=#388 id=388 data-nosnippet>388</a> <span class="kw">const </span>FIND: <span class="kw-2">&amp;</span>str = <span class="string">"βèƒôřèÂßÇ"</span>;
<a href=#389 id=389 data-nosnippet>389</a>
<a href=#390 id=390 data-nosnippet>390</a> <span class="kw">let </span>res: IResult&lt;<span class="kw">_</span>, <span class="kw">_</span>, (<span class="kw">_</span>, ErrorKind)&gt; = take_until(FIND)(INPUT);
<a href=#391 id=391 data-nosnippet>391</a> <span class="kw">match </span>res {
<a href=#392 id=392 data-nosnippet>392</a> <span class="prelude-val">Err</span>(Err::Incomplete(<span class="kw">_</span>)) =&gt; (),
<a href=#393 id=393 data-nosnippet>393</a> other =&gt; <span class="macro">panic!</span>(
<a href=#394 id=394 data-nosnippet>394</a> <span class="string">"Parser `take_until` didn't require more input when it should have. \
<a href=#395 id=395 data-nosnippet>395</a> Got `{:?}`."</span>,
<a href=#396 id=396 data-nosnippet>396</a> other
<a href=#397 id=397 data-nosnippet>397</a> ),
<a href=#398 id=398 data-nosnippet>398</a> };
<a href=#399 id=399 data-nosnippet>399</a> }
<a href=#400 id=400 data-nosnippet>400</a>
<a href=#401 id=401 data-nosnippet>401</a> <span class="attr">#[test]
<a href=#402 id=402 data-nosnippet>402</a> </span><span class="kw">fn </span>is_a_succeed() {
<a href=#403 id=403 data-nosnippet>403</a> <span class="kw">const </span>INPUT: <span class="kw-2">&amp;</span>str = <span class="string">"βèƒôřèÂßÇáƒƭèř"</span>;
<a href=#404 id=404 data-nosnippet>404</a> <span class="kw">const </span>MATCH: <span class="kw-2">&amp;</span>str = <span class="string">"βèƒôřèÂßÇ"</span>;
<a href=#405 id=405 data-nosnippet>405</a> <span class="kw">const </span>CONSUMED: <span class="kw-2">&amp;</span>str = <span class="string">"βèƒôřèÂßÇ"</span>;
<a href=#406 id=406 data-nosnippet>406</a> <span class="kw">const </span>LEFTOVER: <span class="kw-2">&amp;</span>str = <span class="string">"áƒƭèř"</span>;
<a href=#407 id=407 data-nosnippet>407</a> <span class="kw">fn </span>test(input: <span class="kw-2">&amp;</span>str) -&gt; IResult&lt;<span class="kw-2">&amp;</span>str, <span class="kw-2">&amp;</span>str&gt; {
<a href=#408 id=408 data-nosnippet>408</a> is_a(MATCH)(input)
<a href=#409 id=409 data-nosnippet>409</a> }
<a href=#410 id=410 data-nosnippet>410</a> <span class="kw">match </span>test(INPUT) {
<a href=#411 id=411 data-nosnippet>411</a> <span class="prelude-val">Ok</span>((extra, output)) =&gt; {
<a href=#412 id=412 data-nosnippet>412</a> <span class="macro">assert!</span>(
<a href=#413 id=413 data-nosnippet>413</a> extra == LEFTOVER,
<a href=#414 id=414 data-nosnippet>414</a> <span class="string">"Parser `is_a` consumed leftover input. Leftover `{}`."</span>,
<a href=#415 id=415 data-nosnippet>415</a> extra
<a href=#416 id=416 data-nosnippet>416</a> );
<a href=#417 id=417 data-nosnippet>417</a> <span class="macro">assert!</span>(
<a href=#418 id=418 data-nosnippet>418</a> output == CONSUMED,
<a href=#419 id=419 data-nosnippet>419</a> <span class="string">"Parser `is_a` doesn't return the string it consumed on success. Expected `{}`, got `{}`."</span>,
<a href=#420 id=420 data-nosnippet>420</a> CONSUMED,
<a href=#421 id=421 data-nosnippet>421</a> output
<a href=#422 id=422 data-nosnippet>422</a> );
<a href=#423 id=423 data-nosnippet>423</a> }
<a href=#424 id=424 data-nosnippet>424</a> other =&gt; <span class="macro">panic!</span>(
<a href=#425 id=425 data-nosnippet>425</a> <span class="string">"Parser `is_a` didn't succeed when it should have. \
<a href=#426 id=426 data-nosnippet>426</a> Got `{:?}`."</span>,
<a href=#427 id=427 data-nosnippet>427</a> other
<a href=#428 id=428 data-nosnippet>428</a> ),
<a href=#429 id=429 data-nosnippet>429</a> };
<a href=#430 id=430 data-nosnippet>430</a> }
<a href=#431 id=431 data-nosnippet>431</a>
<a href=#432 id=432 data-nosnippet>432</a> <span class="attr">#[test]
<a href=#433 id=433 data-nosnippet>433</a> </span><span class="kw">fn </span>take_while1_fail() {
<a href=#434 id=434 data-nosnippet>434</a> <span class="kw">use </span><span class="kw">crate</span>::bytes::complete::take_while1;
<a href=#435 id=435 data-nosnippet>435</a>
<a href=#436 id=436 data-nosnippet>436</a> <span class="kw">const </span>INPUT: <span class="kw-2">&amp;</span>str = <span class="string">"βèƒôřèÂßÇáƒƭèř"</span>;
<a href=#437 id=437 data-nosnippet>437</a> <span class="kw">fn </span>while1_s(c: char) -&gt; bool {
<a href=#438 id=438 data-nosnippet>438</a> c == <span class="string">'9'
<a href=#439 id=439 data-nosnippet>439</a> </span>}
<a href=#440 id=440 data-nosnippet>440</a> <span class="kw">fn </span>test(input: <span class="kw-2">&amp;</span>str) -&gt; IResult&lt;<span class="kw-2">&amp;</span>str, <span class="kw-2">&amp;</span>str&gt; {
<a href=#441 id=441 data-nosnippet>441</a> take_while1(while1_s)(input)
<a href=#442 id=442 data-nosnippet>442</a> }
<a href=#443 id=443 data-nosnippet>443</a> <span class="kw">match </span>test(INPUT) {
<a href=#444 id=444 data-nosnippet>444</a> <span class="prelude-val">Err</span>(Err::Error(<span class="kw">_</span>)) =&gt; (),
<a href=#445 id=445 data-nosnippet>445</a> other =&gt; <span class="macro">panic!</span>(
<a href=#446 id=446 data-nosnippet>446</a> <span class="string">"Parser `take_while1` didn't fail when it should have. \
<a href=#447 id=447 data-nosnippet>447</a> Got `{:?}`."</span>,
<a href=#448 id=448 data-nosnippet>448</a> other
<a href=#449 id=449 data-nosnippet>449</a> ),
<a href=#450 id=450 data-nosnippet>450</a> };
<a href=#451 id=451 data-nosnippet>451</a> }
<a href=#452 id=452 data-nosnippet>452</a>
<a href=#453 id=453 data-nosnippet>453</a> <span class="attr">#[test]
<a href=#454 id=454 data-nosnippet>454</a> </span><span class="kw">fn </span>is_a_fail() {
<a href=#455 id=455 data-nosnippet>455</a> <span class="kw">const </span>INPUT: <span class="kw-2">&amp;</span>str = <span class="string">"βèƒôřèÂßÇáƒƭèř"</span>;
<a href=#456 id=456 data-nosnippet>456</a> <span class="kw">const </span>MATCH: <span class="kw-2">&amp;</span>str = <span class="string">"Ûñℓúçƙ¥"</span>;
<a href=#457 id=457 data-nosnippet>457</a> <span class="kw">fn </span>test(input: <span class="kw-2">&amp;</span>str) -&gt; IResult&lt;<span class="kw-2">&amp;</span>str, <span class="kw-2">&amp;</span>str&gt; {
<a href=#458 id=458 data-nosnippet>458</a> is_a(MATCH)(input)
<a href=#459 id=459 data-nosnippet>459</a> }
<a href=#460 id=460 data-nosnippet>460</a> <span class="kw">match </span>test(INPUT) {
<a href=#461 id=461 data-nosnippet>461</a> <span class="prelude-val">Err</span>(Err::Error(<span class="kw">_</span>)) =&gt; (),
<a href=#462 id=462 data-nosnippet>462</a> other =&gt; <span class="macro">panic!</span>(
<a href=#463 id=463 data-nosnippet>463</a> <span class="string">"Parser `is_a` didn't fail when it should have. Got `{:?}`."</span>,
<a href=#464 id=464 data-nosnippet>464</a> other
<a href=#465 id=465 data-nosnippet>465</a> ),
<a href=#466 id=466 data-nosnippet>466</a> };
<a href=#467 id=467 data-nosnippet>467</a> }
<a href=#468 id=468 data-nosnippet>468</a>
<a href=#469 id=469 data-nosnippet>469</a> <span class="attr">#[test]
<a href=#470 id=470 data-nosnippet>470</a> </span><span class="kw">fn </span>take_until_error() {
<a href=#471 id=471 data-nosnippet>471</a> <span class="kw">use </span><span class="kw">crate</span>::bytes::streaming::take_until;
<a href=#472 id=472 data-nosnippet>472</a>
<a href=#473 id=473 data-nosnippet>473</a> <span class="kw">const </span>INPUT: <span class="kw-2">&amp;</span>str = <span class="string">"βèƒôřèÂßÇáƒƭèř"</span>;
<a href=#474 id=474 data-nosnippet>474</a> <span class="kw">const </span>FIND: <span class="kw-2">&amp;</span>str = <span class="string">"Ráñδô₥"</span>;
<a href=#475 id=475 data-nosnippet>475</a>
<a href=#476 id=476 data-nosnippet>476</a> <span class="kw">let </span>res: IResult&lt;<span class="kw">_</span>, <span class="kw">_</span>, (<span class="kw">_</span>, ErrorKind)&gt; = take_until(FIND)(INPUT);
<a href=#477 id=477 data-nosnippet>477</a> <span class="kw">match </span>res {
<a href=#478 id=478 data-nosnippet>478</a> <span class="prelude-val">Err</span>(Err::Incomplete(<span class="kw">_</span>)) =&gt; (),
<a href=#479 id=479 data-nosnippet>479</a> other =&gt; <span class="macro">panic!</span>(
<a href=#480 id=480 data-nosnippet>480</a> <span class="string">"Parser `take_until` didn't fail when it should have. \
<a href=#481 id=481 data-nosnippet>481</a> Got `{:?}`."</span>,
<a href=#482 id=482 data-nosnippet>482</a> other
<a href=#483 id=483 data-nosnippet>483</a> ),
<a href=#484 id=484 data-nosnippet>484</a> };
<a href=#485 id=485 data-nosnippet>485</a> }
<a href=#486 id=486 data-nosnippet>486</a>
<a href=#487 id=487 data-nosnippet>487</a> <span class="attr">#[test]
<a href=#488 id=488 data-nosnippet>488</a> #[cfg(feature = <span class="string">"alloc"</span>)]
<a href=#489 id=489 data-nosnippet>489</a> </span><span class="kw">fn </span>recognize_is_a() {
<a href=#490 id=490 data-nosnippet>490</a> <span class="kw">use crate</span>::{lib::std::vec::Vec, Parser};
<a href=#491 id=491 data-nosnippet>491</a>
<a href=#492 id=492 data-nosnippet>492</a> <span class="kw">let </span>a = <span class="string">"aabbab"</span>;
<a href=#493 id=493 data-nosnippet>493</a> <span class="kw">let </span>b = <span class="string">"ababcd"</span>;
<a href=#494 id=494 data-nosnippet>494</a>
<a href=#495 id=495 data-nosnippet>495</a> <span class="kw">fn </span>f(i: <span class="kw-2">&amp;</span>str) -&gt; IResult&lt;<span class="kw-2">&amp;</span>str, <span class="kw-2">&amp;</span>str&gt; {
<a href=#496 id=496 data-nosnippet>496</a> recognize(many::&lt;<span class="kw">_</span>, <span class="kw">_</span>, Vec&lt;<span class="kw-2">&amp;</span>str&gt;, <span class="kw">_</span>, <span class="kw">_</span>&gt;(
<a href=#497 id=497 data-nosnippet>497</a> <span class="number">1</span>..,
<a href=#498 id=498 data-nosnippet>498</a> alt((tag(<span class="string">"a"</span>), tag(<span class="string">"b"</span>))),
<a href=#499 id=499 data-nosnippet>499</a> ))
<a href=#500 id=500 data-nosnippet>500</a> .parse(i)
<a href=#501 id=501 data-nosnippet>501</a> }
<a href=#502 id=502 data-nosnippet>502</a>
<a href=#503 id=503 data-nosnippet>503</a> <span class="macro">assert_eq!</span>(f(a), <span class="prelude-val">Ok</span>((<span class="kw-2">&amp;</span>a[<span class="number">6</span>..], a)));
<a href=#504 id=504 data-nosnippet>504</a> <span class="macro">assert_eq!</span>(f(b), <span class="prelude-val">Ok</span>((<span class="kw-2">&amp;</span>b[<span class="number">4</span>..], <span class="kw-2">&amp;</span>b[..<span class="number">4</span>])));
<a href=#505 id=505 data-nosnippet>505</a> }
<a href=#506 id=506 data-nosnippet>506</a>
<a href=#507 id=507 data-nosnippet>507</a> <span class="attr">#[test]
<a href=#508 id=508 data-nosnippet>508</a> </span><span class="kw">fn </span>utf8_indexing() {
<a href=#509 id=509 data-nosnippet>509</a> <span class="kw">fn </span>dot(i: <span class="kw-2">&amp;</span>str) -&gt; IResult&lt;<span class="kw-2">&amp;</span>str, <span class="kw-2">&amp;</span>str&gt; {
<a href=#510 id=510 data-nosnippet>510</a> tag(<span class="string">"."</span>)(i)
<a href=#511 id=511 data-nosnippet>511</a> }
<a href=#512 id=512 data-nosnippet>512</a>
<a href=#513 id=513 data-nosnippet>513</a> <span class="kw">let _ </span>= dot(<span class="string">"點"</span>);
<a href=#514 id=514 data-nosnippet>514</a> }
<a href=#515 id=515 data-nosnippet>515</a>
<a href=#516 id=516 data-nosnippet>516</a> <span class="attr">#[cfg(feature = <span class="string">"alloc"</span>)]
<a href=#517 id=517 data-nosnippet>517</a> #[test]
<a href=#518 id=518 data-nosnippet>518</a> </span><span class="kw">fn </span>case_insensitive() {
<a href=#519 id=519 data-nosnippet>519</a> <span class="kw">fn </span>test(i: <span class="kw-2">&amp;</span>str) -&gt; IResult&lt;<span class="kw-2">&amp;</span>str, <span class="kw-2">&amp;</span>str&gt; {
<a href=#520 id=520 data-nosnippet>520</a> tag_no_case(<span class="string">"ABcd"</span>)(i)
<a href=#521 id=521 data-nosnippet>521</a> }
<a href=#522 id=522 data-nosnippet>522</a> <span class="macro">assert_eq!</span>(test(<span class="string">"aBCdefgh"</span>), <span class="prelude-val">Ok</span>((<span class="string">"efgh"</span>, <span class="string">"aBCd"</span>)));
<a href=#523 id=523 data-nosnippet>523</a> <span class="macro">assert_eq!</span>(test(<span class="string">"abcdefgh"</span>), <span class="prelude-val">Ok</span>((<span class="string">"efgh"</span>, <span class="string">"abcd"</span>)));
<a href=#524 id=524 data-nosnippet>524</a> <span class="macro">assert_eq!</span>(test(<span class="string">"ABCDefgh"</span>), <span class="prelude-val">Ok</span>((<span class="string">"efgh"</span>, <span class="string">"ABCD"</span>)));
<a href=#525 id=525 data-nosnippet>525</a> }
<a href=#526 id=526 data-nosnippet>526</a>}
</code></pre></div></section></main></body></html>
File diff suppressed because it is too large Load Diff