Struct Parser

pub struct Parser<'a, I, A> { /* private fields */ }

Implementations

impl<'a, I, A> Parser<'a, I, A>

pub fn new<F>(parse: F) -> Parser<'a, I, A>

where F: Fn(&ParseState<'a, I>) -> ParseResult<'a, I, A> + 'a,

Trait Implementations

impl<'a, I, A, B> Add<Parser<'a, I, B>> for Parser<'a, I, A>

where A: Clone + Debug + 'a, B: Clone + Debug + 'a,

type Output = Parser<'a, I, (A, B)>

The resulting type after applying the + operator.

fn add(self, rhs: Parser<'a, I, B>) -> Self::Output

Performs the + operation.

impl<'a, I, A> BitOr for Parser<'a, I, A>

where A: Debug + 'a,

type Output = Parser<'a, I, A>

The resulting type after applying the | operator.

fn bitor(self, rhs: Parser<'a, I, A>) -> Self::Output

Performs the | operation.

impl<'a, I, A> CacheParser<'a> for Parser<'a, I, A>

fn cache(self) -> Self::P<'a, Self::Input, Self::Output>

where Self::Input: Clone + 'a, Self::Output: Clone + Debug + 'a,

impl<'a, I, A> Clone for Parser<'a, I, A>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a, I, A> CollectParser<'a> for Parser<'a, I, A>

fn collect(self) -> Self::P<'a, Self::Input, &'a [Self::Input]>

where Self::Output: Debug + 'a,

impl<'a, I, A> ConversionParser<'a> for Parser<'a, I, A>

fn map_res<B, E, F>(self, f: F) -> Self::P<'a, Self::Input, B>

where F: Fn(Self::Output) -> Result<B, E> + 'a, E: Debug, Self::Output: Debug + 'a, B: Debug + 'a,

impl<'a, I, A> DiscardParser<'a> for Parser<'a, I, A>

fn discard(self) -> Self::P<'a, Self::Input, ()>

where Self::Output: Debug + 'a,

impl<'a, I, A> LoggingParser<'a> for Parser<'a, I, A>

fn log( self, name: &'a str, log_level: LogLevel, ) -> Self::P<'a, Self::Input, Self::Output>

where Self::Input: Debug, Self::Output: Debug + 'a,

fn debug(self, name: &'a str) -> Self::P<'a, Self::Input, Self::Output>

where Self::Input: Debug, Self::Output: Debug + 'a,

fn info(self, name: &'a str) -> Self::P<'a, Self::Input, Self::Output>

where Self::Input: Debug, Self::Output: Debug + 'a,

fn warn(self, name: &'a str) -> Self::P<'a, Self::Input, Self::Output>

where Self::Input: Debug, Self::Output: Debug + 'a,

fn error(self, name: &'a str) -> Self::P<'a, Self::Input, Self::Output>

where Self::Input: Debug, Self::Output: Debug + 'a,

fn name(self, name: &'a str) -> Self::P<'a, Self::Input, Self::Output>

where Self::Input: Debug, Self::Output: Debug + 'a,

impl<'a, I, A, B> Mul<Parser<'a, I, B>> for Parser<'a, I, A>

where A: Clone + Debug + 'a, B: Clone + Debug + 'a,

type Output = Parser<'a, I, B>

The resulting type after applying the * operator.

fn mul(self, rhs: Parser<'a, I, B>) -> Self::Output

Performs the * operation.

impl<'a, I, A> Not for Parser<'a, I, A>

where A: Debug + 'a,

type Output = Parser<'a, I, ()>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<'a, I, A> OffsetParser<'a> for Parser<'a, I, A>

fn last_offset(self) -> Self::P<'a, Self::Input, usize>

where Self::Output: Debug + 'a,

fn next_offset(self) -> Self::P<'a, Self::Input, usize>

where Self::Output: Debug + 'a,

impl<'a, I, A> OperatorParser<'a> for Parser<'a, I, A>

fn and_then<B>( self, pb: Self::P<'a, Self::Input, B>, ) -> Self::P<'a, Self::Input, (Self::Output, B)>

where Self::Output: Clone + Debug + 'a, B: Clone + Debug + 'a,

fn or( self, pb: Self::P<'a, Self::Input, Self::Output>, ) -> Self::P<'a, Self::Input, Self::Output>

where Self::Output: Debug + 'a,

fn exists(self) -> Self::P<'a, Self::Input, bool>

where Self::Output: Debug + 'a,

fn not(self) -> Self::P<'a, Self::Input, ()>

where Self::Output: Debug + 'a,

fn opt(self) -> Self::P<'a, Self::Input, Option<Self::Output>>

where Self::Output: Clone + Debug + 'a,

fn attempt(self) -> Self::P<'a, Self::Input, Self::Output>

where Self::Output: Debug + 'a,

fn scan_right1<BOP>( self, op: Self::P<'a, Self::Input, BOP>, ) -> Self::P<'a, Self::Input, Self::Output>

where BOP: Fn(Self::Output, Self::Output) -> Self::Output + 'a, Self::Output: Clone + Debug + 'a,

fn chain_right0<BOP>( self, op: Self::P<'a, Self::Input, BOP>, x: Self::Output, ) -> Self::P<'a, Self::Input, Self::Output>

where BOP: Fn(Self::Output, Self::Output) -> Self::Output + 'a, Self::Output: Clone + Debug + 'a,

fn chain_left0<BOP>( self, op: Self::P<'a, Self::Input, BOP>, x: Self::Output, ) -> Self::P<'a, Self::Input, Self::Output>

where BOP: Fn(Self::Output, Self::Output) -> Self::Output + 'a, Self::Output: Clone + Debug + 'a,

fn chain_right1<BOP>( self, op: Self::P<'a, Self::Input, BOP>, ) -> Self::P<'a, Self::Input, Self::Output>

where BOP: Fn(Self::Output, Self::Output) -> Self::Output + 'a, Self::Output: Clone + Debug + 'a,

fn chain_left1<BOP>( self, op: Self::P<'a, Self::Input, BOP>, ) -> Self::P<'a, Self::Input, Self::Output>

where BOP: Fn(Self::Output, Self::Output) -> Self::Output + 'a, Self::Output: Clone + Debug + 'a,

fn rest_right1<BOP>( self, op: Self::P<'a, Self::Input, BOP>, x: Self::Output, ) -> Self::P<'a, Self::Input, Self::Output>

where BOP: Fn(Self::Output, Self::Output) -> Self::Output + 'a, Self::Output: Clone + Debug + 'a,

fn rest_left1<BOP>( self, op: Self::P<'a, Self::Input, BOP>, x: Self::Output, ) -> Self::P<'a, Self::Input, Self::Output>

where BOP: Fn(Self::Output, Self::Output) -> Self::Output + 'a, Self::Output: Clone + Debug + 'a,

impl<'a, I, A> ParserFilter<'a> for Parser<'a, I, A>

fn with_filter<F>(self, f: F) -> Self::P<'a, Self::Input, Self::Output>

where F: Fn(&Self::Output) -> bool + 'a, Self::Input: 'a, Self::Output: 'a,

解析結果をフィルターする[Parser]を返す。

fn with_filter_not<F>(self, f: F) -> Self

where F: Fn(&Self::Output) -> bool + 'a, Self::Input: 'a, Self::Output: 'a, Self: Sized,

解析結果をフィルターする[Parser]を返す。

impl<'a, I, A> ParserFunctor<'a> for Parser<'a, I, A>

fn map<B, F>(self, f: F) -> Self::P<'a, Self::Input, B>

where F: Fn(Self::Output) -> B + 'a, Self::Input: 'a, Self::Output: Clone + 'a, B: Clone + 'a,

Returns a [Parser] that transforms the analysis results.
解析結果を変換する[Parser]を返す。

impl<'a, I, A> ParserMonad<'a> for Parser<'a, I, A>

fn flat_map<B, F>(self, f: F) -> Self::P<'a, Self::Input, B>

where F: Fn(Self::Output) -> Self::P<'a, Self::Input, B> + 'a, Self::Input: 'a, Self::Output: 'a, B: 'a,

Returns a Parser that somehow combines the calculations of Parsers.
Parserどうしの計算を何らかの形で結合したParserを返す。

impl<'a, I, A> ParserPure<'a> for Parser<'a, I, A>

fn pure<F>(value: F) -> Self::P<'a, Self::Input, Self::Output>

where F: Fn() -> Self::Output + 'a, Self::Input: 'a, Self::Output: 'a,

Returns the specified value [Parser].
指定した値を返す[Parser]を返す。

impl<'a, I, A> ParserRunner<'a> for Parser<'a, I, A>

type Input = I

type Output = A

type P<'m, X, Y> = Parser<'m, X, Y> where X: 'm

fn parse( &self, input: &'a [Self::Input], ) -> ParseResult<'a, Self::Input, Self::Output>

Analyze input value(for ParseResult).
入力を解析する。

fn run( &self, param: &ParseState<'a, Self::Input>, ) -> ParseResult<'a, Self::Input, Self::Output>

Analyze input value(for ParseResult).
入力を解析する。

fn parse_as_result( &self, input: &'a [Self::Input], ) -> Result<Self::Output, ParseError<'a, Self::Input>>

Analyze input value(for Result).
入力を解析する。

impl<'a, I, A> PeekParser<'a> for Parser<'a, I, A>

fn peek(self) -> Self::P<'a, Self::Input, Self::Output>

where Self::Output: Debug + 'a,

impl<'a, I, A> RepeatParser<'a> for Parser<'a, I, A>

fn repeat<R>(self, range: R) -> Self::P<'a, Self::Input, Vec<Self::Output>>

where R: RangeArgument<usize> + Debug + 'a, Self::Output: Debug + 'a, Self: Sized,

fn of_many0(self) -> Self::P<'a, Self::Input, Vec<Self::Output>>

where Self::Output: Debug + 'a,

fn of_many1(self) -> Self::P<'a, Self::Input, Vec<Self::Output>>

where Self::Output: Debug + 'a,

fn of_many_n_m( self, n: usize, m: usize, ) -> Self::P<'a, Self::Input, Vec<Self::Output>>

where Self::Output: Debug + 'a,

fn of_count(self, n: usize) -> Self::P<'a, Self::Input, Vec<Self::Output>>

where Self::Output: Debug + 'a,

fn of_rep_sep<B, R>( self, range: R, separator: Option<Self::P<'a, Self::Input, B>>, ) -> Self::P<'a, Self::Input, Vec<Self::Output>>

where R: RangeArgument<usize> + Debug + 'a, Self::Output: Debug + 'a, B: Debug + 'a,

fn of_many0_sep<B>( self, separator: Self::P<'a, Self::Input, B>, ) -> Self::P<'a, Self::Input, Vec<Self::Output>>

where Self::Output: Debug + 'a, B: Debug + 'a,

fn of_many1_sep<B>( self, separator: Self::P<'a, Self::Input, B>, ) -> Self::P<'a, Self::Input, Vec<Self::Output>>

where Self::Output: Debug + 'a, B: Debug + 'a,

fn of_many_n_m_sep<B>( self, n: usize, m: usize, separator: Self::P<'a, Self::Input, B>, ) -> Self::P<'a, Self::Input, Vec<Self::Output>>

where Self::Output: Debug + 'a, B: Debug + 'a,

fn of_count_sep<B>( self, n: usize, separator: Self::P<'a, Self::Input, B>, ) -> Self::P<'a, Self::Input, Vec<Self::Output>>

where Self::Output: Debug + 'a, B: Debug + 'a,

impl<'a, I, A> SkipParser<'a> for Parser<'a, I, A>

fn skip_left<B>( self, pb: Self::P<'a, Self::Input, B>, ) -> Self::P<'a, Self::Input, B>

where Self::Output: Clone + Debug + 'a, B: Clone + Debug + 'a,

fn skip_right<B>( self, pb: Self::P<'a, Self::Input, B>, ) -> Self::P<'a, Self::Input, Self::Output>

where Self::Output: Clone + Debug + 'a, B: Clone + Debug + 'a,

fn surround<B, C>( self, left_parser: Self::P<'a, Self::Input, B>, right_parser: Self::P<'a, Self::Input, C>, ) -> Self::P<'a, Self::Input, Self::Output>

where Self::Output: Clone + Debug + 'a, B: Clone + Debug + 'a, C: Clone + Debug + 'a,

impl<'a, I, A, B> Sub<Parser<'a, I, B>> for Parser<'a, I, A>

where A: Clone + Debug + 'a, B: Clone + Debug + 'a,

type Output = Parser<'a, I, A>

The resulting type after applying the - operator.

fn sub(self, rhs: Parser<'a, I, B>) -> Self::Output

Performs the - operation.