Struct ParseWhile 

pub struct ParseWhile<F>(pub F)
where
    F: Fn(char) -> bool;

Keep parsing characters while some predicate is met. If none of the characters meet the predicate, and error will be returned. If this is not desired, try using ParseWhileOrNothing

Example

use parlib::parsers::ParseWhile;
use parlib::traits::Parser;

let parse_numbers = ParseWhile(|c| c.is_numeric());
let answer_valid = parse_numbers.parse("123a 1234");
assert_eq!(answer_valid, Ok(("123".to_string(), "a 1234".to_string())));

In the following example, and error will be returned, since none of the characters met the predicate is_numeric

use parlib::parsers::ParseWhile;
use parlib::traits::Parser;
use parlib::errors::ParsingError;

let parse_numbers = ParseWhile(|c| c.is_numeric());
let answer_bad = parse_numbers.parse("x123a 1234");
assert_eq!(
    answer_bad,
    Err(ParsingError::PatternNotFound(
        "no characters matched predicate".to_string()
    ))
);

Tuple Fields

0: F

Trait Implementations

impl<F> Clone for ParseWhile<F>

where F: Fn(char) -> bool + Clone,

fn clone(&self) -> ParseWhile<F>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<F> Copy for ParseWhile<F>

where F: Fn(char) -> bool + Copy,

impl<F> Debug for ParseWhile<F>

where F: Fn(char) -> bool + Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<F> Parser for ParseWhile<F>

where F: Fn(char) -> bool,

type Output = String

fn parse(&self, input: &str) -> ParserRes<Self::Output>

Parse the input string, if the parser is sucessful, it will return Ok((parsed, rest)), where parsed is the data that was parsed from the string, and the rest is what was left over.

fn parse_and_then_map<F, MappedOutput>( &self, input: &str, f: F, ) -> ParserRes<MappedOutput>

where F: FnOnce(Self::Output) -> MappedOutput,

Parse the output (see parse function), and if sucessful, map the parsed output

fn and_then<P>(self, other: P) -> AndThenParser<Self, P, IdentityAndCombinator>

where P: Parser,

Make a new parser that consists of this parser, followed by another parser.

fn and_then_combine_with<P, C>( self, other: P, combinator: C, ) -> AndThenParser<Self, P, C>

where P: Parser, C: AndCombinator<Self::Output, P::Output>,

fn otherwise<P>(self, other: P) -> OrThenParser<Self, P>

where P: Parser,

Make a new parser that consists of this parser OR another parser.

fn with_mapping<T>( self, mapping: &dyn Fn(Self::Output) -> T, ) -> MapParser<'_, Self, T>

fn with_try_mapping<T>( self, try_map: &dyn Fn(Self::Output) -> Option<T>, ) -> TryMapParser<'_, Self, T>

fn preceed<P>(self, other: P) -> AndThenParser<P, Self, KeepSecondOutputOnly>

where P: Parser,

Preceed this parser with another parser