Struct DynBoxSliceCopied

pub struct DynBoxSliceCopied<Output, T>
where
    Output: Tuple,
    T: Copy,
{ /* private fields */ }

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

This can take any parser with Output of Output.

Once you wrap the parser with this, you can only use input iterator of std::iter::Copied<std::slice::Iter>.

Default is implemented, with always-panic-parser

use rusty_parser as rp;
use rp::IntoParser;

let mut parser = rp::DynBoxSliceCopied::<(i32,), i32>::default();
// #[should_panic]
// let res = rp::parse(&parser, (&[1,2,3]).iter().copied());

parser.assign( 0..=9 );
let res = rp::parse(&parser, (&[1,2,3,4,5,6]).iter().copied());
assert_eq!( res.output.unwrap(), (1,) );

Implementations

impl<Output, T> DynBoxSliceCopied<Output, T>

where Output: Tuple, T: Copy,

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

where ParserType::Into: for<'a> Parser<Copied<Iter<'a, T>>, Output = Output> + 'static,

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

where ParserType::Into: for<'a> Parser<Copied<Iter<'a, T>>, Output = Output> + 'static,

Trait Implementations

impl<Output: Tuple + 'static, T: Copy + 'static> Default for DynBoxSliceCopied<Output, T>

default to dummy parser that always panic

fn default() -> Self

Returns the “default value” for a type.

impl<Output, T> Deref for DynBoxSliceCopied<Output, T>

where Output: Tuple, T: Copy,

type Target = Box<dyn for<'a> Parser<Copied<Iter<'a, T>>, Output = Output>>

The resulting type after dereferencing.

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

Dereferences the value.

impl<Output, T> DerefMut for DynBoxSliceCopied<Output, T>

where Output: Tuple, T: Copy,

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

Mutably dereferences the value.

impl<Output, T> IntoParser for DynBoxSliceCopied<Output, T>

where Output: Tuple, T: Copy,

type Into = DynBoxSliceCopied<Output, T>

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<RangeTypeIncludeInteger>( self, range: RangeTypeIncludeInteger, ) -> RepeatParser<Self::Into, RangeTypeIncludeInteger::Into>

where Self: Sized, RangeTypeIncludeInteger: ToCopyable, RangeTypeIncludeInteger::Into: RangeBound<usize>,

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>( self, callback: ClosureType, ) -> MapParser<Self::Into, ClosureType>

where 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 crate::match_pattern() instead of crate::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>( self, output: Output, ) -> OptionalOrParser<Self::Into, Output>

where Self: Sized,

This parser always success whether the input is matched or not. If it failed, the given value will be returned.

fn or_else<Closure>( self, closure: Closure, ) -> OptionalOrElseParser<Self::Into, Closure>

where Self: Sized,

This parser always success whether the input is matched or not. If it failed, the given closure will be evaluated and returned.

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

where Self: Sized,

Match for parser1 but not parser2.

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

where Self: Sized,

Change Parser’s Output to (output,).

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

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

Returns Vec\<T\> of parsed input. Only works for parsing with ExactSizeIterator.

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

where Self: Sized,

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

fn reduce_left<RhsParser, Reducer>( self, rhs: RhsParser, reducer: Reducer, ) -> ReduceLeftParser<Self::Into, RhsParser::Into, Reducer>

where Self: Sized, RhsParser: IntoParser,

Reduce the output of the parser with the given reducer.

fn reduce_right<LhsParser, Reducer>( self, lhs: LhsParser, reducer: Reducer, ) -> ReduceRightParser<LhsParser::Into, Self::Into, Reducer>

where Self: Sized, LhsParser: IntoParser,

Reduce the output of the parser with the given reducer.

fn reduce_with<Init, Reducer>( self, init: Init, reducer: Reducer, ) -> ReduceInitParser<Self::Into, Init, Reducer>

where Self: Sized, Init: Clone,

Reduce the output of the parser with the given reducer.

fn reduce_right_with<Init, Reducer>( self, init: Init, reducer: Reducer, ) -> ReduceRightInitParser<Self::Into, Init, Reducer>

where Self: Sized, Init: Clone,

Reduce the output of the parser with the given reducer.

fn inspect<ClosureType>( self, closure: ClosureType, ) -> InspectParser<Self::Into, ClosureType>

where Self: Sized, ClosureType: Fn(),

This does what std::iter::Inspect do. The closure will be called before parsing, regardless of the success or failure of the parser.

impl<'a, Output, T> Parser<Copied<Iter<'a, T>>> for DynBoxSliceCopied<Output, T>

where Output: Tuple, T: Copy,

type Output = Output

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

fn match_pattern( &self, it: Copied<Iter<'a, T>>, ) -> ParseResult<(), Copied<Iter<'a, T>>>