Lines Matching refs:Err
8 use crate::internal::{Err, IResult, Needed, Parser};
28 /// This stops on [`Err::Error`] and returns the results that were accumulated. To instead chain an error up, see
38 /// # use nom::{Err, error::ErrorKind, Needed, IResult};
64 Err(Err::Error(_)) => return Ok((i, acc)),
65 Err(e) => return Err(e),
69 return Err(Err::Error(E::from_error_kind(i, ErrorKind::Many0)));
82 /// This stops on [`Err::Error`] if there is at least one result, and returns the results that were accumulated. To instead chain an error up,
93 /// # use nom::{Err, error::{Error, ErrorKind}, Needed, IResult};
103 /// assert_eq!(parser("123123"), Err(Err::Error(Error::new("123123", ErrorKind::Tag))));
104 /// assert_eq!(parser(""), Err(Err::Error(Error::new("", ErrorKind::Tag))));
115 Err(Err::Error(err)) => Err(Err::Error(E::append(i, ErrorKind::Many1, err))),
116 Err(e) => Err(e),
125 Err(Err::Error(_)) => return Ok((i, acc)),
126 Err(e) => return Err(e),
130 return Err(Err::Error(E::from_error_kind(i, ErrorKind::Many1)));
146 /// `f` keeps going so long as `g` produces [`Err::Error`]. To instead chain an error up, see [`cut`][crate::combinator::cut].
149 /// # use nom::{Err, error::{Error, ErrorKind}, Needed, IResult};
158 /// assert_eq!(parser("abc123end"), Err(Err::Error(Error::new("123end", ErrorKind::Tag))));
159 /// assert_eq!(parser("123123end"), Err(Err::Error(Error::new("123123end", ErrorKind::Tag))));
160 /// assert_eq!(parser(""), Err(Err::Error(Error::new("", ErrorKind::Tag))));
181 Err(Err::Error(_)) => {
183 Err(Err::Error(err)) => return Err(Err::Error(E::append(i, ErrorKind::ManyTill, err))),
184 Err(e) => return Err(e),
188 return Err(Err::Error(E::from_error_kind(i1, ErrorKind::ManyTill)));
196 Err(e) => return Err(e),
204 /// This stops when either parser returns [`Err::Error`] and returns the results that were accumulated. To instead chain an error up, see
212 /// # use nom::{Err, error::ErrorKind, Needed, IResult};
242 Err(Err::Error(_)) => return Ok((i, res)),
243 Err(e) => return Err(e),
253 Err(Err::Error(_)) => return Ok((i, res)),
254 Err(e) => return Err(e),
258 return Err(Err::Error(E::from_error_kind(i1, ErrorKind::SeparatedList)));
262 Err(Err::Error(_)) => return Ok((i, res)),
263 Err(e) => return Err(e),
275 /// Alternates between two parsers to produce a list of elements until [`Err::Error`].
279 /// This stops when either parser returns [`Err::Error`] and returns the results that were accumulated. To instead chain an error up, see
286 /// # use nom::{Err, error::{Error, ErrorKind}, Needed, IResult};
297 /// assert_eq!(parser(""), Err(Err::Error(Error::new("", ErrorKind::Tag))));
298 /// assert_eq!(parser("def|abc"), Err(Err::Error(Error::new("def|abc", ErrorKind::Tag))));
317 Err(e) => return Err(e),
327 Err(Err::Error(_)) => return Ok((i, res)),
328 Err(e) => return Err(e),
332 return Err(Err::Error(E::from_error_kind(i1, ErrorKind::SeparatedList)));
336 Err(Err::Error(_)) => return Ok((i, res)),
337 Err(e) => return Err(e),
351 /// This stops before `n` when the parser returns [`Err::Error`] and returns the results that were accumulated. To instead chain an error up, see
364 /// # use nom::{Err, error::ErrorKind, Needed, IResult};
392 return Err(Err::Failure(E::from_error_kind(input, ErrorKind::ManyMN)));
404 return Err(Err::Error(E::from_error_kind(input, ErrorKind::ManyMN)));
410 Err(Err::Error(e)) => {
412 return Err(Err::Error(E::append(input, ErrorKind::ManyMN, e)));
417 Err(e) => {
418 return Err(e);
429 /// This stops on [`Err::Error`]. To instead chain an error up, see
439 /// # use nom::{Err, error::ErrorKind, Needed, IResult};
469 return Err(Err::Error(E::from_error_kind(input, ErrorKind::Many0Count)));
476 Err(Err::Error(_)) => return Ok((input, count)),
478 Err(e) => return Err(e),
486 /// This stops on [`Err::Error`] if there is at least one result. To instead chain an error up,
497 /// # use nom::{Err, error::{Error, ErrorKind}, Needed, IResult};
507 /// assert_eq!(parser("123123"), Err(Err::Error(Error::new("123123", ErrorKind::Many1Count))));
508 /// assert_eq!(parser(""), Err(Err::Error(Error::new("", ErrorKind::Many1Count))));
519 Err(Err::Error(_)) => Err(Err::Error(E::from_error_kind(i, ErrorKind::Many1Count))),
520 Err(i) => Err(i),
529 Err(Err::Error(_)) => return Ok((input, count)),
530 Err(e) => return Err(e),
534 return Err(Err::Error(E::from_error_kind(i, ErrorKind::Many1Count)));
553 /// # use nom::{Err, error::{Error, ErrorKind}, Needed, IResult};
562 /// assert_eq!(parser("abc123"), Err(Err::Error(Error::new("123", ErrorKind::Tag))));
563 /// assert_eq!(parser("123123"), Err(Err::Error(Error::new("123123", ErrorKind::Tag))));
564 /// assert_eq!(parser(""), Err(Err::Error(Error::new("", ErrorKind::Tag))));
588 Err(Err::Error(e)) => {
589 return Err(Err::Error(E::append(i, ErrorKind::Count, e)));
591 Err(e) => {
592 return Err(e);
609 /// # use nom::{Err, error::{Error, ErrorKind}, Needed, IResult};
620 /// assert_eq!(parser("abc123"), Err(Err::Error(Error::new("123", ErrorKind::Tag))));
621 /// assert_eq!(parser("123123"), Err(Err::Error(Error::new("123123", ErrorKind::Tag))));
622 /// assert_eq!(parser(""), Err(Err::Error(Error::new("", ErrorKind::Tag))));
641 Err(Err::Error(e)) => {
642 return Err(Err::Error(E::append(i, ErrorKind::Count, e)));
644 Err(e) => {
645 return Err(e);
656 /// This stops on [`Err::Error`]. To instead chain an error up, see
669 /// # use nom::{Err, error::ErrorKind, Needed, IResult};
712 return Err(Err::Error(E::from_error_kind(input, ErrorKind::Many0)));
718 Err(Err::Error(_)) => {
721 Err(e) => {
722 return Err(e);
731 /// This stops on [`Err::Error`] if there is at least one result. To instead chain an error up,
745 /// # use nom::{Err, error::{Error, ErrorKind}, Needed, IResult};
762 /// assert_eq!(parser("123123"), Err(Err::Error(Error::new("123123", ErrorKind::Many1))));
763 /// assert_eq!(parser(""), Err(Err::Error(Error::new("", ErrorKind::Many1))));
781 Err(Err::Error(_)) => Err(Err::Error(E::from_error_kind(i, ErrorKind::Many1))),
782 Err(e) => Err(e),
791 Err(Err::Error(_)) => {
794 Err(e) => return Err(e),
798 return Err(Err::Failure(E::from_error_kind(i, ErrorKind::Many1)));
815 /// This stops before `n` when the parser returns [`Err::Error`]. To instead chain an error up, see
831 /// # use nom::{Err, error::ErrorKind, Needed, IResult};
870 return Err(Err::Failure(E::from_error_kind(input, ErrorKind::ManyMN)));
880 return Err(Err::Error(E::from_error_kind(tail, ErrorKind::ManyMN)));
887 Err(Err::Error(err)) => {
889 return Err(Err::Error(E::append(input, ErrorKind::ManyMN, err)));
894 Err(e) => return Err(e),
909 /// # use nom::{Err, error::ErrorKind, Needed, IResult};
919 /// assert_eq!(parser(b"\x00\x03a"), Err(Err::Incomplete(Needed::new(2))));
937 Err(Err::Incomplete(Needed::Size(needed)))
953 /// # use nom::{Err, error::{Error, ErrorKind}, Needed, IResult};
963 /// assert_eq!(parser(b"\x00\x03123123"), Err(Err::Error(Error::new(&b"123"[..], ErrorKind::Tag))));
964 /// assert_eq!(parser(b"\x00\x03a"), Err(Err::Incomplete(Needed::new(2))));
983 Err(Err::Incomplete(Needed::Size(needed)))
987 Err(Err::Incomplete(_)) => Err(Err::Error(E::from_error_kind(i, ErrorKind::Complete))),
988 Err(e) => Err(e),
1001 /// # use nom::{Err, error::{Error, ErrorKind}, Needed, IResult};
1015 /// assert_eq!(parser(b"\x03123123123"), Err(Err::Error(Error::new(&b"123123123"[..], ErrorKind::Tag))));
1038 Err(Err::Error(e)) => {
1039 return Err(Err::Error(E::append(i, ErrorKind::Count, e)));
1041 Err(e) => {
1042 return Err(e);