Lines Matching refs:parser
56 /// Maps a function on the result of a parser.
64 /// let mut parser = map(digit1, |s: &str| s.len());
66 /// // the parser will count how many characters were returned by digit1
67 /// assert_eq!(parser.parse("123456"), Ok(("", 6)));
70 /// assert_eq!(parser.parse("abc"), Err(Err::Error(("abc", ErrorKind::Digit))));
73 pub fn map<I, O1, O2, E, F, G>(mut parser: F, mut f: G) -> impl FnMut(I) -> IResult<I, O2, E>
79 let (input, o1) = parser.parse(input)?;
84 /// Applies a function returning a `Result` over the result of a parser.
94 /// // the parser will convert the result of digit1 to a number
105 mut parser: F,
114 let (input, o1) = parser.parse(input)?;
122 /// Applies a function returning an `Option` over the result of a parser.
132 /// // the parser will convert the result of digit1 to a number
143 mut parser: F,
152 let (input, o1) = parser.parse(input)?;
160 /// Applies a parser over the result of another one.
177 mut parser: F,
185 let (input, o1) = parser.parse(input)?;
191 /// Creates a new parser from the output of the first parser, then apply that parser over the rest of the input.
207 mut parser: F,
216 let (input, o1) = parser.parse(input)?;
221 /// Optional parser, will return `None` on [`Err::Error`].
231 /// fn parser(i: &str) -> IResult<&str, Option<&str>> {
235 /// assert_eq!(parser("abcd;"), Ok((";", Some("abcd"))));
236 /// assert_eq!(parser("123;"), Ok(("123;", None)));
253 /// Calls the parser if the condition is met.
261 /// fn parser(b: bool, i: &str) -> IResult<&str, Option<&str>> {
265 /// assert_eq!(parser(true, "abcd;"), Ok((";", Some("abcd"))));
266 /// assert_eq!(parser(false, "abcd;"), Ok(("abcd;", None)));
267 /// assert_eq!(parser(true, "123;"), Err(Err::Error(Error::new("123;", ErrorKind::Alpha))));
268 /// assert_eq!(parser(false, "123;"), Ok(("123;", None)));
290 /// Tries to apply its parser without consuming the input.
298 /// let mut parser = peek(alpha1);
300 /// assert_eq!(parser("abcd;"), Ok(("abcd;", "abcd")));
301 /// assert_eq!(parser("123;"), Err(Err::Error(("123;", ErrorKind::Alpha))));
328 /// let parser = eof;
329 /// assert_eq!(parser("abc"), Err(Err::Error(("abc", ErrorKind::Eof))));
330 /// assert_eq!(parser(""), Ok(("", "")));
350 /// let mut parser = complete(take(5u8));
352 /// assert_eq!(parser("abcdefg"), Ok(("fg", "abcde")));
353 /// assert_eq!(parser("abcd"), Err(Err::Error(("abcd", ErrorKind::Complete))));
369 /// Succeeds if all the input has been consumed by its child parser.
377 /// let mut parser = all_consuming(alpha1);
379 /// assert_eq!(parser("abcd"), Ok(("", "abcd")));
380 /// assert_eq!(parser("abcd;"),Err(Err::Error((";", ErrorKind::Eof))));
381 /// assert_eq!(parser("123abcd;"),Err(Err::Error(("123abcd;", ErrorKind::Alpha))));
399 /// Returns the result of the child parser if it satisfies a verification function.
402 /// parser.
410 /// let mut parser = verify(alpha1, |s: &str| s.len() == 4);
412 /// assert_eq!(parser("abcd"), Ok(("", "abcd")));
413 /// assert_eq!(parser("abcde"), Err(Err::Error(("abcde", ErrorKind::Verify))));
414 /// assert_eq!(parser("123abcd;"),Err(Err::Error(("123abcd;", ErrorKind::Alpha))));
439 /// Returns the provided value if the child parser succeeds.
447 /// let mut parser = value(1234, alpha1);
449 /// assert_eq!(parser("abcd"), Ok(("", 1234)));
450 /// assert_eq!(parser("123abcd;"), Err(Err::Error(("123abcd;", ErrorKind::Alpha))));
455 mut parser: F,
460 move |input: I| parser.parse(input).map(|(i, _)| (i, val.clone()))
463 /// Succeeds if the child parser returns an error.
471 /// let mut parser = not(alpha1);
473 /// assert_eq!(parser("123"), Ok(("123", ())));
474 /// assert_eq!(parser("abcd"), Err(Err::Error(("abcd", ErrorKind::Not))));
477 pub fn not<I: Clone, O, E: ParseError<I>, F>(mut parser: F) -> impl FnMut(I) -> IResult<I, (), E>
483 match parser.parse(input) {
491 /// If the child parser was successful, return the consumed input as produced value.
500 /// let mut parser = recognize(separated_pair(alpha1, char(','), alpha1));
502 /// assert_eq!(parser("abcd,efgh"), Ok(("", "abcd,efgh")));
503 /// assert_eq!(parser("abcd;"),Err(Err::Error((";", ErrorKind::Char))));
507 mut parser: F,
514 match parser.parse(i) {
524 /// if the child parser was successful, return the consumed input with the output
526 /// returns the parser output as well.
553 /// // should be the same as that of the `recognize` parser.
561 pub fn consumed<I, O, F, E>(mut parser: F) -> impl FnMut(I) -> IResult<I, (I, O), E>
569 match parser.parse(i) {
596 /// fn parser(input: &str) -> IResult<&str, &str> {
603 /// assert_eq!(parser("+10 ab"), Ok((" ab", "10")));
604 /// assert_eq!(parser("ab"), Ok(("", "ab")));
605 /// assert_eq!(parser("+"), Ok(("", "+")));
619 /// fn parser(input: &str) -> IResult<&str, &str> {
626 /// assert_eq!(parser("+10 ab"), Ok((" ab", "10")));
627 /// assert_eq!(parser("ab"), Ok(("", "ab")));
628 /// assert_eq!(parser("+"), Err(Err::Failure(Error { input: "", code: ErrorKind::Digit })));
631 pub fn cut<I, O, E: ParseError<I>, F>(mut parser: F) -> impl FnMut(I) -> IResult<I, O, E>
635 move |input: I| match parser.parse(input) {
641 /// automatically converts the child parser's result to another type
658 /// // the parser converts the &str output of the child parser into a Vec<u8>
663 pub fn into<I, O1, O2, E1, E2, F>(mut parser: F) -> impl FnMut(I) -> IResult<I, O2, E2>
671 //map(parser, Into::into)
672 move |input: I| match parser.parse(input) {
680 /// Creates an iterator from input data and a parser.
773 /// a parser which always succeeds with given value without consuming any input.
785 /// let mut parser = success::<_,_,(_,ErrorKind)>(10);
786 /// assert_eq!(parser("xyz"), Ok(("xyz", 10)));
798 /// A parser which always fails.