1 //! combinators applying parsers in sequence
2
3 #[macro_use]
4 mod macros;
5
6 use crate::internal::IResult;
7 use crate::error::ParseError;
8
9 /// Gets an object from the first parser,
10 /// then gets another object from the second parser.
11 ///
12 /// # Arguments
13 /// * `first` The first parser to apply.
14 /// * `second` The second parser to apply.
15 /// ```rust
16 /// # use nom::{Err, error::ErrorKind, Needed};
17 /// # use nom::Needed::Size;
18 /// use nom::sequence::pair;
19 /// use nom::bytes::complete::tag;
20 ///
21 /// let parser = pair(tag("abc"), tag("efg"));
22 ///
23 /// assert_eq!(parser("abcefg"), Ok(("", ("abc", "efg"))));
24 /// assert_eq!(parser("abcefghij"), Ok(("hij", ("abc", "efg"))));
25 /// assert_eq!(parser(""), Err(Err::Error(("", ErrorKind::Tag))));
26 /// assert_eq!(parser("123"), Err(Err::Error(("123", ErrorKind::Tag))));
27 /// ```
pair<I, O1, O2, E: ParseError<I>, F, G>(first: F, second: G) -> impl Fn(I) -> IResult<I, (O1, O2), E> where F: Fn(I) -> IResult<I, O1, E>, G: Fn(I) -> IResult<I, O2, E>,28 pub fn pair<I, O1, O2, E: ParseError<I>, F, G>(first: F, second: G) -> impl Fn(I) -> IResult<I, (O1, O2), E>
29 where
30 F: Fn(I) -> IResult<I, O1, E>,
31 G: Fn(I) -> IResult<I, O2, E>,
32 {
33 move |input: I| {
34 let (input, o1) = first(input)?;
35 second(input).map(|(i, o2)| (i, (o1, o2)))
36 }
37 }
38
39 // this implementation is used for type inference issues in macros
40 #[doc(hidden)]
pairc<I, O1, O2, E: ParseError<I>, F, G>(input: I, first: F, second: G) -> IResult<I, (O1, O2), E> where F: Fn(I) -> IResult<I, O1, E>, G: Fn(I) -> IResult<I, O2, E>,41 pub fn pairc<I, O1, O2, E: ParseError<I>, F, G>(input: I, first: F, second: G) -> IResult<I, (O1, O2), E>
42 where
43 F: Fn(I) -> IResult<I, O1, E>,
44 G: Fn(I) -> IResult<I, O2, E>,
45 {
46 pair(first, second)(input)
47 }
48
49 /// Matches an object from the first parser and discards it,
50 /// then gets an object from the second parser.
51 ///
52 /// # Arguments
53 /// * `first` The opening parser.
54 /// * `second` The second parser to get object.
55 /// ```rust
56 /// # use nom::{Err, error::ErrorKind, Needed};
57 /// # use nom::Needed::Size;
58 /// use nom::sequence::preceded;
59 /// use nom::bytes::complete::tag;
60 ///
61 /// let parser = preceded(tag("abc"), tag("efg"));
62 ///
63 /// assert_eq!(parser("abcefg"), Ok(("", "efg")));
64 /// assert_eq!(parser("abcefghij"), Ok(("hij", "efg")));
65 /// assert_eq!(parser(""), Err(Err::Error(("", ErrorKind::Tag))));
66 /// assert_eq!(parser("123"), Err(Err::Error(("123", ErrorKind::Tag))));
67 /// ```
preceded<I, O1, O2, E: ParseError<I>, F, G>(first: F, second: G) -> impl Fn(I) -> IResult<I, O2, E> where F: Fn(I) -> IResult<I, O1, E>, G: Fn(I) -> IResult<I, O2, E>,68 pub fn preceded<I, O1, O2, E: ParseError<I>, F, G>(first: F, second: G) -> impl Fn(I) -> IResult<I, O2, E>
69 where
70 F: Fn(I) -> IResult<I, O1, E>,
71 G: Fn(I) -> IResult<I, O2, E>,
72 {
73 move |input: I| {
74 let (input, _) = first(input)?;
75 second(input)
76 }
77 }
78
79 // this implementation is used for type inference issues in macros
80 #[doc(hidden)]
precededc<I, O1, O2, E: ParseError<I>, F, G>(input: I, first: F, second: G) -> IResult<I, O2, E> where F: Fn(I) -> IResult<I, O1, E>, G: Fn(I) -> IResult<I, O2, E>,81 pub fn precededc<I, O1, O2, E: ParseError<I>, F, G>(input: I, first: F, second: G) -> IResult<I, O2, E>
82 where
83 F: Fn(I) -> IResult<I, O1, E>,
84 G: Fn(I) -> IResult<I, O2, E>,
85 {
86 preceded(first, second)(input)
87 }
88
89 /// Gets an object from the first parser,
90 /// then matches an object from the second parser and discards it.
91 ///
92 /// # Arguments
93 /// * `first` The first parser to apply.
94 /// * `second` The second parser to match an object.
95 /// ```rust
96 /// # use nom::{Err, error::ErrorKind, Needed};
97 /// # use nom::Needed::Size;
98 /// use nom::sequence::terminated;
99 /// use nom::bytes::complete::tag;
100 ///
101 /// let parser = terminated(tag("abc"), tag("efg"));
102 ///
103 /// assert_eq!(parser("abcefg"), Ok(("", "abc")));
104 /// assert_eq!(parser("abcefghij"), Ok(("hij", "abc")));
105 /// assert_eq!(parser(""), Err(Err::Error(("", ErrorKind::Tag))));
106 /// assert_eq!(parser("123"), Err(Err::Error(("123", ErrorKind::Tag))));
107 /// ```
terminated<I, O1, O2, E: ParseError<I>, F, G>(first: F, second: G) -> impl Fn(I) -> IResult<I, O1, E> where F: Fn(I) -> IResult<I, O1, E>, G: Fn(I) -> IResult<I, O2, E>,108 pub fn terminated<I, O1, O2, E: ParseError<I>, F, G>(first: F, second: G) -> impl Fn(I) -> IResult<I, O1, E>
109 where
110 F: Fn(I) -> IResult<I, O1, E>,
111 G: Fn(I) -> IResult<I, O2, E>,
112 {
113 move |input: I| {
114 let (input, o1) = first(input)?;
115 second(input).map(|(i, _)| (i, o1))
116 }
117 }
118
119 // this implementation is used for type inference issues in macros
120 #[doc(hidden)]
terminatedc<I, O1, O2, E: ParseError<I>, F, G>(input: I, first: F, second: G) -> IResult<I, O1, E> where F: Fn(I) -> IResult<I, O1, E>, G: Fn(I) -> IResult<I, O2, E>,121 pub fn terminatedc<I, O1, O2, E: ParseError<I>, F, G>(input: I, first: F, second: G) -> IResult<I, O1, E>
122 where
123 F: Fn(I) -> IResult<I, O1, E>,
124 G: Fn(I) -> IResult<I, O2, E>,
125 {
126 terminated(first, second)(input)
127 }
128
129 /// Gets an object from the first parser,
130 /// then matches an object from the sep_parser and discards it,
131 /// then gets another object from the second parser.
132 ///
133 /// # Arguments
134 /// * `first` The first parser to apply.
135 /// * `sep` The separator parser to apply.
136 /// * `second` The second parser to apply.
137 /// ```rust
138 /// # use nom::{Err, error::ErrorKind, Needed};
139 /// # use nom::Needed::Size;
140 /// use nom::sequence::separated_pair;
141 /// use nom::bytes::complete::tag;
142 ///
143 /// let parser = separated_pair(tag("abc"), tag("|"), tag("efg"));
144 ///
145 /// assert_eq!(parser("abc|efg"), Ok(("", ("abc", "efg"))));
146 /// assert_eq!(parser("abc|efghij"), Ok(("hij", ("abc", "efg"))));
147 /// assert_eq!(parser(""), Err(Err::Error(("", ErrorKind::Tag))));
148 /// assert_eq!(parser("123"), Err(Err::Error(("123", ErrorKind::Tag))));
149 /// ```
separated_pair<I, O1, O2, O3, E: ParseError<I>, F, G, H>(first: F, sep: G, second: H) -> impl Fn(I) -> IResult<I, (O1, O3), E> where F: Fn(I) -> IResult<I, O1, E>, G: Fn(I) -> IResult<I, O2, E>, H: Fn(I) -> IResult<I, O3, E>,150 pub fn separated_pair<I, O1, O2, O3, E: ParseError<I>, F, G, H>(first: F, sep: G, second: H) -> impl Fn(I) -> IResult<I, (O1, O3), E>
151 where
152 F: Fn(I) -> IResult<I, O1, E>,
153 G: Fn(I) -> IResult<I, O2, E>,
154 H: Fn(I) -> IResult<I, O3, E>,
155 {
156 move |input: I| {
157 let (input, o1) = first(input)?;
158 let (input, _) = sep(input)?;
159 second(input).map(|(i, o2)| (i, (o1, o2)))
160 }
161 }
162
163 // this implementation is used for type inference issues in macros
164 #[doc(hidden)]
separated_pairc<I, O1, O2, O3, E: ParseError<I>, F, G, H>(input: I, first: F, sep: G, second: H) -> IResult<I, (O1, O3), E> where F: Fn(I) -> IResult<I, O1, E>, G: Fn(I) -> IResult<I, O2, E>, H: Fn(I) -> IResult<I, O3, E>,165 pub fn separated_pairc<I, O1, O2, O3, E: ParseError<I>, F, G, H>(input: I, first: F, sep: G, second: H) -> IResult<I, (O1, O3), E>
166 where
167 F: Fn(I) -> IResult<I, O1, E>,
168 G: Fn(I) -> IResult<I, O2, E>,
169 H: Fn(I) -> IResult<I, O3, E>,
170 {
171 separated_pair(first, sep, second)(input)
172 }
173
174 /// Matches an object from the first parser,
175 /// then gets an object from the sep_parser,
176 /// then matches another object from the second parser.
177 ///
178 /// # Arguments
179 /// * `first` The first parser to apply.
180 /// * `sep` The separator parser to apply.
181 /// * `second` The second parser to apply.
182 /// ```rust
183 /// # use nom::{Err, error::ErrorKind, Needed};
184 /// # use nom::Needed::Size;
185 /// use nom::sequence::delimited;
186 /// use nom::bytes::complete::tag;
187 ///
188 /// let parser = delimited(tag("abc"), tag("|"), tag("efg"));
189 ///
190 /// assert_eq!(parser("abc|efg"), Ok(("", "|")));
191 /// assert_eq!(parser("abc|efghij"), Ok(("hij", "|")));
192 /// assert_eq!(parser(""), Err(Err::Error(("", ErrorKind::Tag))));
193 /// assert_eq!(parser("123"), Err(Err::Error(("123", ErrorKind::Tag))));
194 /// ```
delimited<I, O1, O2, O3, E: ParseError<I>, F, G, H>(first: F, sep: G, second: H) -> impl Fn(I) -> IResult<I, O2, E> where F: Fn(I) -> IResult<I, O1, E>, G: Fn(I) -> IResult<I, O2, E>, H: Fn(I) -> IResult<I, O3, E>,195 pub fn delimited<I, O1, O2, O3, E: ParseError<I>, F, G, H>(first: F, sep: G, second: H) -> impl Fn(I) -> IResult<I, O2, E>
196 where
197 F: Fn(I) -> IResult<I, O1, E>,
198 G: Fn(I) -> IResult<I, O2, E>,
199 H: Fn(I) -> IResult<I, O3, E>,
200 {
201 move |input: I| {
202 let (input, _) = first(input)?;
203 let (input, o2) = sep(input)?;
204 second(input).map(|(i, _)| (i, o2))
205 }
206 }
207
208 // this implementation is used for type inference issues in macros
209 #[doc(hidden)]
delimitedc<I, O1, O2, O3, E: ParseError<I>, F, G, H>(input: I, first: F, sep: G, second: H) -> IResult<I, O2, E> where F: Fn(I) -> IResult<I, O1, E>, G: Fn(I) -> IResult<I, O2, E>, H: Fn(I) -> IResult<I, O3, E>,210 pub fn delimitedc<I, O1, O2, O3, E: ParseError<I>, F, G, H>(input: I, first: F, sep: G, second: H) -> IResult<I, O2, E>
211 where
212 F: Fn(I) -> IResult<I, O1, E>,
213 G: Fn(I) -> IResult<I, O2, E>,
214 H: Fn(I) -> IResult<I, O3, E>,
215 {
216 delimited(first, sep, second)(input)
217 }
218
219 /// helper trait for the tuple combinator
220 ///
221 /// this trait is implemented for tuples of parsers of up to 21 elements
222 pub trait Tuple<I,O,E> {
223 /// parses the input and returns a tuple of results of each parser
parse(&self, input: I) -> IResult<I,O,E>224 fn parse(&self, input: I) -> IResult<I,O,E>;
225 }
226
227 impl<Input, Output, Error: ParseError<Input>, F: Fn(Input) -> IResult<Input, Output, Error> > Tuple<Input, (Output,), Error> for (F,) {
parse(&self, input: Input) -> IResult<Input,(Output,),Error>228 fn parse(&self, input: Input) -> IResult<Input,(Output,),Error> {
229 self.0(input).map(|(i,o)| (i, (o,)))
230 }
231 }
232
233 macro_rules! tuple_trait(
234 ($name1:ident $ty1:ident, $name2: ident $ty2:ident, $($name:ident $ty:ident),*) => (
235 tuple_trait!(__impl $name1 $ty1, $name2 $ty2; $($name $ty),*);
236 );
237 (__impl $($name:ident $ty: ident),+; $name1:ident $ty1:ident, $($name2:ident $ty2:ident),*) => (
238 tuple_trait_impl!($($name $ty),+);
239 tuple_trait!(__impl $($name $ty),+ , $name1 $ty1; $($name2 $ty2),*);
240 );
241 (__impl $($name:ident $ty: ident),+; $name1:ident $ty1:ident) => (
242 tuple_trait_impl!($($name $ty),+);
243 tuple_trait_impl!($($name $ty),+, $name1 $ty1);
244 );
245 );
246
247 macro_rules! tuple_trait_impl(
248 ($($name:ident $ty: ident),+) => (
249 impl<
250 Input: Clone, $($ty),+ , Error: ParseError<Input>,
251 $($name: Fn(Input) -> IResult<Input, $ty, Error>),+
252 > Tuple<Input, ( $($ty),+ ), Error> for ( $($name),+ ) {
253
254 fn parse(&self, input: Input) -> IResult<Input, ( $($ty),+ ), Error> {
255 tuple_trait_inner!(0, self, input, (), $($name)+)
256
257 }
258 }
259 );
260 );
261
262 macro_rules! tuple_trait_inner(
263 ($it:tt, $self:expr, $input:expr, (), $head:ident $($id:ident)+) => ({
264 let (i, o) = $self.$it($input.clone())?;
265
266 succ!($it, tuple_trait_inner!($self, i, ( o ), $($id)+))
267 });
268 ($it:tt, $self:expr, $input:expr, ($($parsed:tt)*), $head:ident $($id:ident)+) => ({
269 let (i, o) = $self.$it($input.clone())?;
270
271 succ!($it, tuple_trait_inner!($self, i, ($($parsed)* , o), $($id)+))
272 });
273 ($it:tt, $self:expr, $input:expr, ($($parsed:tt)*), $head:ident) => ({
274 let (i, o) = $self.$it($input.clone())?;
275
276 Ok((i, ($($parsed)* , o)))
277 });
278 );
279
280 tuple_trait!(FnA A, FnB B, FnC C, FnD D, FnE E, FnF F, FnG G, FnH H, FnI I, FnJ J, FnK K, FnL L,
281 FnM M, FnN N, FnO O, FnP P, FnQ Q, FnR R, FnS S, FnT T, FnU U);
282
283 /// applies a tuple of parsers one by one and returns their results as a tuple
284 ///
285 /// ```rust
286 /// # use nom::{Err, error::ErrorKind};
287 /// use nom::sequence::tuple;
288 /// use nom::character::complete::{alpha1, digit1};
289 /// let parser = tuple((alpha1, digit1, alpha1));
290 ///
291 /// assert_eq!(parser("abc123def"), Ok(("", ("abc", "123", "def"))));
292 /// assert_eq!(parser("123def"), Err(Err::Error(("123def", ErrorKind::Alpha))));
293 /// ```
tuple<I: Clone, O, E: ParseError<I>, List: Tuple<I,O,E>>(l: List) -> impl Fn(I) -> IResult<I, O, E>294 pub fn tuple<I: Clone, O, E: ParseError<I>, List: Tuple<I,O,E>>(l: List) -> impl Fn(I) -> IResult<I, O, E> {
295 move |i: I| {
296 l.parse(i)
297 }
298 }
299
300 #[cfg(test)]
301 mod tests {
302 use super::*;
303
304 #[test]
single_element_tuples()305 fn single_element_tuples() {
306 use crate::character::complete::{alpha1, digit1};
307 use crate::{Err, error::ErrorKind};
308
309 let parser = tuple((alpha1,));
310 assert_eq!(parser("abc123def"), Ok(("123def", ("abc",))));
311 assert_eq!(parser("123def"), Err(Err::Error(("123def", ErrorKind::Alpha))));
312 }
313 }
314