Struct rusty_parser::DynBoxChars

pub struct DynBoxChars<Output>
where
    Output: Tuple,
{ /* private fields */ }

A Box<dyn Parser> wrapper for iterators of std::str::Chars.

This can take any parser with Output of Output.

Once you wrap the parser with this, you can only use input iterator of std::str::Chars.

Implementations

impl<Output> DynBoxChars<Output>

where Output: Tuple,

pub fn new<ParserType: IntoParser>(parser: ParserType) -> Self

where ParserType::Into: for<'a> Parser<Chars<'a>, Output = Output> + 'static,

pub fn assign<ParserType: IntoParser>(&mut self, parser: ParserType)

where ParserType::Into: for<'a> Parser<Chars<'a>, Output = Output> + 'static,

Trait Implementations

impl<Output> Deref for DynBoxChars<Output>

where Output: Tuple,

type Target = Box<dyn for<'a> Parser<Chars<'a>, Output = Output>>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<Output> DerefMut for DynBoxChars<Output>

where Output: Tuple,

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<Output> IntoParser for DynBoxChars<Output>

where Output: Tuple,

type Into = DynBoxChars<Output>

Target Parser type

fn into_parser(self) -> Self::Into

convert self to Parser

fn seq<RhsParser: IntoParser>( self, rhs: RhsParser ) -> SeqParser<Self::Into, RhsParser::Into>

where Self: Sized,

concatenate two parser

fn repeat<Idx, RangeType>( self, range_: RangeType ) -> RepeatParser<Self::Into, RangeType, Idx>

where Self: Sized, RangeType: RangeBounds<Idx>, Idx: PartialOrd + PartialEq + PartialOrd<i32> + PartialEq<i32>, i32: PartialOrd + PartialEq + PartialOrd<Idx> + PartialEq<Idx>,

repeat parser multiple times. This tries to match as long as possible.

fn or<RhsParser: IntoParser>( self, rhs: RhsParser ) -> OrParser<Self::Into, RhsParser::Into>

where Self: Sized,

or combinator for two parsers

fn map<ClosureType, ClosureInput, ClosureOutput>( self, callback: ClosureType ) -> MapParser<Self::Into, ClosureType, ClosureInput, ClosureOutput>

where ClosureInput: Tuple, ClosureType: Fn(ClosureInput) -> ClosureOutput, ClosureOutput: Tuple, Self: Sized,

Map parser’s Output to new value

fn void(self) -> VoidParser<Self::Into>

where Self: Sized,

Change Parser’s Output to (). This internally call match_pattern() instead of parse()

fn optional(self) -> OptionalParser<Self::Into>

where Self: Sized,

This parser always success whether the input is matched or not.

fn optional_or<Output: Clone + Tuple>( self, output: Output ) -> OptionalOrParser<Self::Into, Output>

where Self: Sized,

This parser always success whether the input is matched or not.

fn refcell(self) -> RefCelledParser<Self::Into>

where Self: Sized,

create RefCell<Parser> wrapper.

fn rc(self) -> RcedParser<Self::Into>

where Self: Sized,

Create Rc<Parser> wrapper.

fn box_slice<Output, T>(self) -> DynBoxSlice<Output, T>

where Output: Tuple, T: Clone + Copy, Self: Sized, Self::Into: for<'a> Parser<Copied<Iter<'a, T>>, Output = Output> + 'static,

create a Box<dyn Parser> wrapper for iterators of std::iter::Copied<std::slice::Iter>.

fn not<RhsParser: IntoParser>( self, rhs: RhsParser ) -> NotParser<Self::Into, RhsParser::Into>

where Self: Sized,

Match for parser1 parser2, parser1 must success and parser2 must fail.

fn output<Output: Tuple + Clone>( self, output: Output ) -> OutputParser<Self::Into, Output>

where Self: Sized,

Change Parser’s Output to output.

fn vec<T>(self) -> SliceParser<Self::Into>

where Self: Sized, Self::Into: for<'a> Parser<Copied<Iter<'a, T>>>,

Returns Vec\<T\> of parsed input. Only works for parsing with std::iter::Copied<std::slice::Iter>.

fn not_consume(self) -> NotConsumeParser<Self::Into>

where Self: Sized,

Parser will not consume the input iterator. It still match and return the output.

impl<'a, Output> Parser<Chars<'a>> for DynBoxChars<Output>

where Output: Tuple,

type Output = Output

fn parse(&self, it: Chars<'a>) -> ParseResult<Self::Output, Chars<'a>>

fn match_pattern(&self, it: Chars<'a>) -> ParseResult<(), Chars<'a>>