//! General purpose combinators #![allow(unused_imports)] use core::marker::PhantomData; #[cfg(feature = "alloc")] use crate::lib::std::boxed::Box; use crate::error::{ErrorKind, FromExternalError, ParseError}; use crate::internal::*; use crate::lib::std::borrow::Borrow; use crate::lib::std::convert::Into; #[cfg(feature = "std")] use crate::lib::std::fmt::Debug; use crate::lib::std::mem::transmute; use crate::lib::std::ops::{Range, RangeFrom, RangeTo}; use crate::traits::{AsChar, Input, ParseTo}; use crate::traits::{Compare, CompareResult, Offset}; #[cfg(test)] mod tests; /// Return the remaining input. /// /// ```rust /// # use nom::error::ErrorKind; /// use nom::combinator::rest; /// assert_eq!(rest::<_,(_, ErrorKind)>("abc"), Ok(("", "abc"))); /// assert_eq!(rest::<_,(_, ErrorKind)>(""), Ok(("", ""))); /// ``` #[inline] pub fn rest>(input: T) -> IResult where T: Input, { Ok(input.take_split(input.input_len())) } /// Return the length of the remaining input. /// /// ```rust /// # use nom::error::ErrorKind; /// use nom::combinator::rest_len; /// assert_eq!(rest_len::<_,(_, ErrorKind)>("abc"), Ok(("abc", 3))); /// assert_eq!(rest_len::<_,(_, ErrorKind)>(""), Ok(("", 0))); /// ``` #[inline] pub fn rest_len>(input: T) -> IResult where T: Input, { let len = input.input_len(); Ok((input, len)) } /// Maps a function on the result of a parser. /// /// ```rust /// use nom::{Err,error::ErrorKind, IResult, Parser}; /// use nom::character::complete::digit1; /// use nom::combinator::map; /// # fn main() { /// /// let mut parser = map(digit1, |s: &str| s.len()); /// /// // the parser will count how many characters were returned by digit1 /// assert_eq!(parser.parse("123456"), Ok(("", 6))); /// /// // this will fail if digit1 fails /// assert_eq!(parser.parse("abc"), Err(Err::Error(("abc", ErrorKind::Digit)))); /// # } /// ``` pub fn map, F, G>(parser: F, f: G) -> impl Parser where F: Parser, G: FnMut(>::Output) -> O, { parser.map(f) } /// Applies a function returning a `Result` over the result of a parser. /// /// ```rust /// # use nom::{Err,error::ErrorKind, IResult, Parser}; /// use nom::character::complete::digit1; /// use nom::combinator::map_res; /// # fn main() { /// /// let mut parse = map_res(digit1, |s: &str| s.parse::()); /// /// // the parser will convert the result of digit1 to a number /// assert_eq!(parse.parse("123"), Ok(("", 123))); /// /// // this will fail if digit1 fails /// assert_eq!(parse.parse("abc"), Err(Err::Error(("abc", ErrorKind::Digit)))); /// /// // this will fail if the mapped function fails (a `u8` is too small to hold `123456`) /// assert_eq!(parse.parse("123456"), Err(Err::Error(("123456", ErrorKind::MapRes)))); /// # } /// ``` pub fn map_res + FromExternalError, E2, F, G>( parser: F, f: G, ) -> impl Parser where F: Parser, G: FnMut(>::Output) -> Result, { parser.map_res(f) } /// Applies a function returning an `Option` over the result of a parser. /// /// ```rust /// # use nom::{Err,error::ErrorKind, IResult, Parser}; /// use nom::character::complete::digit1; /// use nom::combinator::map_opt; /// # fn main() { /// /// let mut parse = map_opt(digit1, |s: &str| s.parse::().ok()); /// /// // the parser will convert the result of digit1 to a number /// assert_eq!(parse.parse("123"), Ok(("", 123))); /// /// // this will fail if digit1 fails /// assert_eq!(parse.parse("abc"), Err(Err::Error(("abc", ErrorKind::Digit)))); /// /// // this will fail if the mapped function fails (a `u8` is too small to hold `123456`) /// assert_eq!(parse.parse("123456"), Err(Err::Error(("123456", ErrorKind::MapOpt)))); /// # } /// ``` pub fn map_opt, F, G>( parser: F, f: G, ) -> impl Parser where F: Parser, G: FnMut(>::Output) -> Option, { parser.map_opt(f) } /// Applies a parser over the result of another one. /// /// ```rust /// # use nom::{Err,error::ErrorKind, IResult, Parser}; /// use nom::character::complete::digit1; /// use nom::bytes::complete::take; /// use nom::combinator::map_parser; /// # fn main() { /// /// let mut parse = map_parser(take(5u8), digit1); /// /// assert_eq!(parse.parse("12345"), Ok(("", "12345"))); /// assert_eq!(parse.parse("123ab"), Ok(("", "123"))); /// assert_eq!(parse.parse("123"), Err(Err::Error(("123", ErrorKind::Eof)))); /// # } /// ``` pub fn map_parser, F, G>( parser: F, applied_parser: G, ) -> impl Parser where F: Parser, G: Parser<>::Output, Output = O, Error = E>, { parser.and_then(applied_parser) } /// Creates a new parser from the output of the first parser, then apply that parser over the rest of the input. /// /// ```rust /// # use nom::{Err,error::ErrorKind, IResult, Parser}; /// use nom::bytes::complete::take; /// use nom::number::complete::u8; /// use nom::combinator::flat_map; /// # fn main() { /// /// let mut parse = flat_map(u8, take); /// /// assert_eq!(parse.parse(&[2, 0, 1, 2][..]), Ok((&[2][..], &[0, 1][..]))); /// assert_eq!(parse.parse(&[4, 0, 1, 2][..]), Err(Err::Error((&[0, 1, 2][..], ErrorKind::Eof)))); /// # } /// ``` pub fn flat_map, F, G, H>( parser: F, applied_parser: G, ) -> impl Parser where F: Parser, G: FnMut(>::Output) -> H, H: Parser, { parser.flat_map(applied_parser) } /// Optional parser, will return `None` on [`Err::Error`]. /// /// To chain an error up, see [`cut`]. /// /// ```rust /// # use nom::{Err,error::ErrorKind, IResult, Parser}; /// use nom::combinator::opt; /// use nom::character::complete::alpha1; /// # fn main() { /// /// fn parser(i: &str) -> IResult<&str, Option<&str>> { /// opt(alpha1).parse(i) /// } /// /// assert_eq!(parser("abcd;"), Ok((";", Some("abcd")))); /// assert_eq!(parser("123;"), Ok(("123;", None))); /// # } /// ``` pub fn opt, F>( f: F, ) -> impl Parser>::Output>, Error = E> where F: Parser, { Opt { parser: f } } /// Parser implementation for [opt] pub struct Opt { parser: F, } impl> Parser for Opt where I: Clone, { type Output = Option<>::Output>; type Error = >::Error; #[inline(always)] fn process(&mut self, input: I) -> PResult { let i = input.clone(); match self .parser .process::>(input) { Ok((i, o)) => Ok((i, OM::Output::map(o, Some))), Err(Err::Error(_)) => Ok((i, OM::Output::bind(|| None))), Err(Err::Failure(e)) => Err(Err::Failure(e)), Err(Err::Incomplete(i)) => Err(Err::Incomplete(i)), } } } /// Calls the parser if the condition is met. /// /// ```rust /// # use nom::{Err, error::{Error, ErrorKind}, IResult, Parser}; /// use nom::combinator::cond; /// use nom::character::complete::alpha1; /// # fn main() { /// /// fn parser(b: bool, i: &str) -> IResult<&str, Option<&str>> { /// cond(b, alpha1).parse(i) /// } /// /// assert_eq!(parser(true, "abcd;"), Ok((";", Some("abcd")))); /// assert_eq!(parser(false, "abcd;"), Ok(("abcd;", None))); /// assert_eq!(parser(true, "123;"), Err(Err::Error(Error::new("123;", ErrorKind::Alpha)))); /// assert_eq!(parser(false, "123;"), Ok(("123;", None))); /// # } /// ``` pub fn cond, F>( b: bool, f: F, ) -> impl Parser>::Output>, Error = E> where F: Parser, { Cond { parser: if b { Some(f) } else { None }, } } /// Parser implementation for [cond] pub struct Cond { parser: Option, } impl Parser for Cond where F: Parser, { type Output = Option<>::Output>; type Error = >::Error; fn process(&mut self, input: I) -> PResult { match &mut self.parser { None => Ok((input, OM::Output::bind(|| None))), Some(f) => f .process::(input) .map(|(i, o)| (i, OM::Output::map(o, Some))), } } } /// Tries to apply its parser without consuming the input. /// /// ```rust /// # use nom::{Err,error::ErrorKind, IResult, Parser}; /// use nom::combinator::peek; /// use nom::character::complete::alpha1; /// # fn main() { /// /// let mut parser = peek(alpha1); /// /// assert_eq!(parser.parse("abcd;"), Ok(("abcd;", "abcd"))); /// assert_eq!(parser.parse("123;"), Err(Err::Error(("123;", ErrorKind::Alpha)))); /// # } /// ``` pub fn peek( parser: F, ) -> impl Parser>::Output, Error = >::Error> where F: Parser, { Peek { parser } } /// Parsr implementation for [peek] pub struct Peek { parser: F, } impl Parser for Peek where I: Clone, F: Parser, { type Output = >::Output; type Error = >::Error; fn process(&mut self, input: I) -> PResult { let i = input.clone(); match self.parser.process::(input) { Ok((_, o)) => Ok((i, o)), Err(e) => Err(e), } } } /// returns its input if it is at the end of input data /// /// When we're at the end of the data, this combinator /// will succeed /// /// ``` /// # use std::str; /// # use nom::{Err, error::ErrorKind, IResult}; /// # use nom::combinator::eof; /// /// # fn main() { /// let parser = eof; /// assert_eq!(parser("abc"), Err(Err::Error(("abc", ErrorKind::Eof)))); /// assert_eq!(parser(""), Ok(("", ""))); /// # } /// ``` pub fn eof>(input: I) -> IResult { if input.input_len() == 0 { let clone = input.clone(); Ok((input, clone)) } else { Err(Err::Error(E::from_error_kind(input, ErrorKind::Eof))) } } /// Transforms Incomplete into `Error`. /// /// ```rust /// # use nom::{Err,error::ErrorKind, IResult, Parser}; /// use nom::bytes::streaming::take; /// use nom::combinator::complete; /// # fn main() { /// /// let mut parser = complete(take(5u8)); /// /// assert_eq!(parser.parse("abcdefg"), Ok(("fg", "abcde"))); /// assert_eq!(parser.parse("abcd"), Err(Err::Error(("abcd", ErrorKind::Complete)))); /// # } /// ``` pub fn complete, F>( parser: F, ) -> impl Parser where F: Parser, { MakeComplete { parser } } /// Parser implementation for [complete] pub struct MakeComplete { parser: F, } impl Parser for MakeComplete where I: Clone, F: Parser, { type Output = >::Output; type Error = >::Error; fn process(&mut self, input: I) -> PResult { let i = input.clone(); match self .parser .process::>(input) { Err(Err::Incomplete(_)) => Err(Err::Error(OM::Error::bind(|| { >::Error::from_error_kind(i, ErrorKind::Complete) }))), Err(e) => Err(e), Ok(o) => Ok(o), } } } /// Succeeds if all the input has been consumed by its child parser. /// /// ```rust /// # use nom::{Err,error::ErrorKind, IResult, Parser}; /// use nom::combinator::all_consuming; /// use nom::character::complete::alpha1; /// # fn main() { /// /// let mut parser = all_consuming(alpha1); /// /// assert_eq!(parser.parse("abcd"), Ok(("", "abcd"))); /// assert_eq!(parser.parse("abcd;"),Err(Err::Error((";", ErrorKind::Eof)))); /// assert_eq!(parser.parse("123abcd;"),Err(Err::Error(("123abcd;", ErrorKind::Alpha)))); /// # } /// ``` pub fn all_consuming, F>( parser: F, ) -> impl Parser>::Output, Error = E> where I: Input, F: Parser, { AllConsuming { parser } } /// Parser implementation for [all_consuming] pub struct AllConsuming { parser: F, } impl Parser for AllConsuming where I: Input, F: Parser, { type Output = >::Output; type Error = >::Error; fn process(&mut self, input: I) -> PResult { let (input, res) = self.parser.process::(input)?; if input.input_len() == 0 { Ok((input, res)) } else { Err(Err::Error(OM::Error::bind(|| { >::Error::from_error_kind(input, ErrorKind::Eof) }))) } } } /// Returns the result of the child parser if it satisfies a verification function. /// /// The verification function takes as argument a reference to the output of the /// parser. /// /// ```rust /// # use nom::{Err,error::ErrorKind, IResult, Parser}; /// use nom::combinator::verify; /// use nom::character::complete::alpha1; /// # fn main() { /// /// let mut parser = verify(alpha1, |s: &str| s.len() == 4); /// /// assert_eq!(parser.parse("abcd"), Ok(("", "abcd"))); /// assert_eq!(parser.parse("abcde"), Err(Err::Error(("abcde", ErrorKind::Verify)))); /// assert_eq!(parser.parse("123abcd;"),Err(Err::Error(("123abcd;", ErrorKind::Alpha)))); /// # } /// ``` pub fn verify, F, G>( first: F, second: G, ) -> impl Parser>::Output, Error = E> where F: Parser, G: Fn(&O2) -> bool, >::Output: Borrow, O2: ?Sized, { Verify { first, second, o2: PhantomData, } } /// Parser iplementation for verify pub struct Verify { first: F, second: G, o2: PhantomData, } impl, G, O2> Parser for Verify where I: Clone, G: Fn(&O2) -> bool, >::Output: Borrow, O2: ?Sized, { type Output = >::Output; type Error = >::Error; fn process(&mut self, input: I) -> PResult { let (i, o) = self .first .process::>(input.clone())?; if (self.second)(o.borrow()) { Ok((i, OM::Output::bind(|| o))) } else { Err(Err::Error(OM::Error::bind(move || { let e: ErrorKind = ErrorKind::Verify; >::Error::from_error_kind(input, e) }))) } } } /// Returns the provided value if the child parser succeeds. /// /// ```rust /// # use nom::{Err,error::ErrorKind, IResult, Parser}; /// use nom::combinator::value; /// use nom::character::complete::alpha1; /// # fn main() { /// /// let mut parser = value(1234, alpha1); /// /// assert_eq!(parser.parse("abcd"), Ok(("", 1234))); /// assert_eq!(parser.parse("123abcd;"), Err(Err::Error(("123abcd;", ErrorKind::Alpha)))); /// # } /// ``` pub fn value, F>( val: O1, parser: F, ) -> impl Parser where F: Parser, { parser.map(move |_| val.clone()) } /// Succeeds if the child parser returns an error. /// /// ```rust /// # use nom::{Err,error::ErrorKind, IResult, Parser}; /// use nom::combinator::not; /// use nom::character::complete::alpha1; /// # fn main() { /// /// let mut parser = not(alpha1); /// /// assert_eq!(parser.parse("123"), Ok(("123", ()))); /// assert_eq!(parser.parse("abcd"), Err(Err::Error(("abcd", ErrorKind::Not)))); /// # } /// ``` pub fn not, F>(parser: F) -> impl Parser where F: Parser, { Not { parser } } /// Parser implementation for [not] pub struct Not { parser: F, } impl Parser for Not where I: Clone, F: Parser, { type Output = (); type Error = >::Error; fn process(&mut self, input: I) -> PResult { let i = input.clone(); match self.parser.process::(input) { Ok(_) => Err(Err::Error(OM::Error::bind(|| { >::Error::from_error_kind(i, ErrorKind::Not) }))), Err(Err::Error(_)) => Ok((i, OM::Output::bind(|| ()))), Err(e) => Err(e), } } } /// If the child parser was successful, return the consumed input as produced value. /// /// ```rust /// # use nom::{Err,error::ErrorKind, IResult, Parser}; /// use nom::combinator::recognize; /// use nom::character::complete::{char, alpha1}; /// use nom::sequence::separated_pair; /// # fn main() { /// /// let mut parser = recognize(separated_pair(alpha1, char(','), alpha1)); /// /// assert_eq!(parser.parse("abcd,efgh"), Ok(("", "abcd,efgh"))); /// assert_eq!(parser.parse("abcd;"),Err(Err::Error((";", ErrorKind::Char)))); /// # } /// ``` pub fn recognize, F>( parser: F, ) -> impl Parser where F: Parser, { Recognize { parser } } /// Parser implementation for [recognize] pub struct Recognize { parser: F, } impl Parser for Recognize where I: Clone + Offset + Input, F: Parser, { type Output = I; type Error = >::Error; #[inline(always)] fn process(&mut self, input: I) -> PResult { let i = input.clone(); match self .parser .process::>(i) { Ok((i, _)) => { let index = input.offset(&i); Ok((i, OM::Output::bind(|| input.take(index)))) } Err(e) => Err(e), } } } /// if the child parser was successful, return the consumed input with the output /// as a tuple. Functions similarly to [recognize](fn.recognize.html) except it /// returns the parser output as well. /// /// This can be useful especially in cases where the output is not the same type /// as the input, or the input is a user defined type. /// /// Returned tuple is of the format `(consumed input, produced output)`. /// /// ```rust /// # use nom::{Err,error::ErrorKind, IResult, Parser}; /// use nom::combinator::{consumed, value, recognize, map}; /// use nom::character::complete::{char, alpha1}; /// use nom::bytes::complete::tag; /// use nom::sequence::separated_pair; /// /// fn inner_parser(input: &str) -> IResult<&str, bool> { /// value(true, tag("1234")).parse(input) /// } /// /// # fn main() { /// /// let mut consumed_parser = consumed(value(true, separated_pair(alpha1, char(','), alpha1))); /// /// assert_eq!(consumed_parser.parse("abcd,efgh1"), Ok(("1", ("abcd,efgh", true)))); /// assert_eq!(consumed_parser.parse("abcd;"),Err(Err::Error((";", ErrorKind::Char)))); /// /// /// // the first output (representing the consumed input) /// // should be the same as that of the `recognize` parser. /// let mut recognize_parser = recognize(inner_parser); /// let mut consumed_parser = map(consumed(inner_parser), |(consumed, output)| consumed); /// /// assert_eq!(recognize_parser.parse("1234"), consumed_parser.parse("1234")); /// assert_eq!(recognize_parser.parse("abcd"), consumed_parser.parse("abcd")); /// # } /// ``` pub fn consumed( parser: F, ) -> impl Parser>::Output), Error = E> where I: Clone + Offset + Input, E: ParseError, F: Parser, { Consumed { parser } } /// Parser implementation for [consumed] pub struct Consumed { parser: F, } impl Parser for Consumed where I: Clone + Offset + Input, F: Parser, { type Output = (I, >::Output); type Error = >::Error; #[inline(always)] fn process(&mut self, input: I) -> PResult { let i = input.clone(); match self.parser.process::(i) { Ok((remaining, result)) => { let index = input.offset(&remaining); Ok(( remaining, OM::Output::map(result, |res| { let consumed = input.take(index); (consumed, res) }), )) } Err(e) => Err(e), } } } /// Transforms an [`Err::Error`] (recoverable) to [`Err::Failure`] (unrecoverable) /// /// This commits the parse result, preventing alternative branch paths like with /// [`nom::branch::alt`][crate::branch::alt]. /// /// # Example /// /// Without `cut`: /// ```rust /// # use nom::{Err,error::ErrorKind, IResult, Parser}; /// # use nom::character::complete::{one_of, digit1}; /// # use nom::combinator::rest; /// # use nom::branch::alt; /// # use nom::sequence::preceded; /// # fn main() { /// /// fn parser(input: &str) -> IResult<&str, &str> { /// alt(( /// preceded(one_of("+-"), digit1), /// rest /// )).parse(input) /// } /// /// assert_eq!(parser("+10 ab"), Ok((" ab", "10"))); /// assert_eq!(parser("ab"), Ok(("", "ab"))); /// assert_eq!(parser("+"), Ok(("", "+"))); /// # } /// ``` /// /// With `cut`: /// ```rust /// # use nom::{Err,error::ErrorKind, IResult, Parser, error::Error}; /// # use nom::character::complete::{one_of, digit1}; /// # use nom::combinator::rest; /// # use nom::branch::alt; /// # use nom::sequence::preceded; /// use nom::combinator::cut; /// # fn main() { /// /// fn parser(input: &str) -> IResult<&str, &str> { /// alt(( /// preceded(one_of("+-"), cut(digit1)), /// rest /// )).parse(input) /// } /// /// assert_eq!(parser("+10 ab"), Ok((" ab", "10"))); /// assert_eq!(parser("ab"), Ok(("", "ab"))); /// assert_eq!(parser("+"), Err(Err::Failure(Error { input: "", code: ErrorKind::Digit }))); /// # } /// ``` pub fn cut, F>( parser: F, ) -> impl Parser>::Output, Error = E> where F: Parser, { Cut { parser } } /// Parser implementation for [cut] pub struct Cut { parser: F, } impl Parser for Cut where F: Parser, { type Output = >::Output; type Error = >::Error; #[inline(always)] fn process(&mut self, input: I) -> PResult { match self .parser .process::>(input) { Err(Err::Error(e)) => Err(Err::Failure(e)), Err(Err::Failure(e)) => Err(Err::Failure(e)), Err(Err::Incomplete(i)) => Err(Err::Incomplete(i)), Ok((i, o)) => Ok((i, o)), } } } /// automatically converts the child parser's result to another type /// /// it will be able to convert the output value and the error value /// as long as the `Into` implementations are available /// /// ```rust /// # use nom::{IResult, Parser}; /// use nom::combinator::into; /// use nom::character::complete::alpha1; /// # fn main() { /// /// fn parser1(i: &str) -> IResult<&str, &str> { /// alpha1(i) /// } /// /// let mut parser2 = into(parser1); /// /// // the parser converts the &str output of the child parser into a Vec /// let bytes: IResult<&str, Vec> = parser2.parse("abcd"); /// assert_eq!(bytes, Ok(("", vec![97, 98, 99, 100]))); /// # } /// ``` pub fn into(parser: F) -> impl Parser where O2: From, E2: From, E1: ParseError, E2: ParseError, F: Parser, { parser.into::() } /// Creates an iterator from input data and a parser. /// /// Call the iterator's [ParserIterator::finish] method to get the remaining input if successful, /// or the error value if we encountered an error. /// /// On [`Err::Error`], iteration will stop. To instead chain an error up, see [`cut`]. /// /// ```rust /// use nom::{combinator::iterator, IResult, bytes::complete::tag, character::complete::alpha1, sequence::terminated}; /// use std::collections::HashMap; /// /// let data = "abc|defg|hijkl|mnopqr|123"; /// let mut it = iterator(data, terminated(alpha1, tag("|"))); /// /// let parsed = it.by_ref().map(|v| (v, v.len())).collect::>(); /// let res: IResult<_,_> = it.finish(); /// /// assert_eq!(parsed, [("abc", 3usize), ("defg", 4), ("hijkl", 5), ("mnopqr", 6)].iter().cloned().collect()); /// assert_eq!(res, Ok(("123", ()))); /// ``` pub fn iterator(input: Input, f: F) -> ParserIterator where F: Parser, Error: ParseError, { ParserIterator { iterator: f, input, state: Some(State::Running), } } /// Main structure associated to the [iterator] function. pub struct ParserIterator { iterator: F, input: I, state: Option>, } impl ParserIterator { /// Returns the remaining input if parsing was successful, or the error if we encountered an error. pub fn finish(mut self) -> IResult { match self.state.take().unwrap() { State::Running | State::Done => Ok((self.input, ())), State::Failure(e) => Err(Err::Failure(e)), State::Incomplete(i) => Err(Err::Incomplete(i)), } } } impl core::iter::Iterator for ParserIterator where F: Parser, Input: Clone, { type Item = Output; fn next(&mut self) -> Option { if let State::Running = self.state.take().unwrap() { let input = self.input.clone(); match (self.iterator).parse(input) { Ok((i, o)) => { self.input = i; self.state = Some(State::Running); Some(o) } Err(Err::Error(_)) => { self.state = Some(State::Done); None } Err(Err::Failure(e)) => { self.state = Some(State::Failure(e)); None } Err(Err::Incomplete(i)) => { self.state = Some(State::Incomplete(i)); None } } } else { None } } } enum State { Running, Done, Failure(E), Incomplete(Needed), } /// a parser which always succeeds with given value without consuming any input. /// /// It can be used for example as the last alternative in `alt` to /// specify the default case. /// /// ```rust /// # use nom::{Err,error::ErrorKind, IResult, Parser}; /// use nom::branch::alt; /// use nom::combinator::{success, value}; /// use nom::character::complete::char; /// # fn main() { /// /// let mut parser = success::<_,_,(_,ErrorKind)>(10); /// assert_eq!(parser.parse("xyz"), Ok(("xyz", 10))); /// /// let mut sign = alt((value(-1, char('-')), value(1, char('+')), success::<_,_,(_,ErrorKind)>(1))); /// assert_eq!(sign.parse("+10"), Ok(("10", 1))); /// assert_eq!(sign.parse("-10"), Ok(("10", -1))); /// assert_eq!(sign.parse("10"), Ok(("10", 1))); /// # } /// ``` pub fn success>(val: O) -> impl Parser { Success { val, e: PhantomData, } } /// Parser implementation for [success] pub struct Success { val: O, e: PhantomData, } impl Parser for Success where O: Clone, E: ParseError, { type Output = O; type Error = E; fn process(&mut self, input: I) -> PResult { Ok((input, OM::Output::bind(|| self.val.clone()))) } } /// A parser which always fails. /// /// ```rust /// # use nom::{Err, error::ErrorKind, IResult, Parser}; /// use nom::combinator::fail; /// /// let s = "string"; /// assert_eq!(fail::<_, &str, _>().parse(s), Err(Err::Error((s, ErrorKind::Fail)))); /// ``` pub fn fail>() -> impl Parser { Fail { o: PhantomData, e: PhantomData, } } /// Parser implementation for [fail] pub struct Fail { o: PhantomData, e: PhantomData, } impl Parser for Fail where E: ParseError, { type Output = O; type Error = E; fn process(&mut self, input: I) -> PResult { Err(Err::Error(OM::Error::bind(|| { E::from_error_kind(input, ErrorKind::Fail) }))) } }