Struct LanguageEnv

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

A type containing parsers for a specific language. For some parsers there are two version where the parser which ends with a _ is a variant which does not skip whitespace and comments after parsing the token itself.

Implementations

impl<'a, I> LanguageEnv<'a, I>

where I: Stream<Token = char>, I::Error: ParseError<I::Token, I::Range, I::Position>,

pub fn new<A, B, C, D, E, F, G>( def: LanguageDef<A, B, C, D, E, F, G>, ) -> LanguageEnv<'a, I>

where A: Parser<I, Output = char> + 'a, B: Parser<I, Output = char> + 'a, C: Parser<I, Output = char> + 'a, D: Parser<I, Output = char> + 'a, E: Parser<I, Output = ()> + 'a, F: Parser<I, Output = ()> + 'a, G: Parser<I, Output = ()> + 'a,

Constructs a new parser from a language defintion

pub fn lex<'b, P>(&'b self, p: P) -> Lex<'a, 'b, P, I>

where P: Parser<I> + 'b,

Creates a lexing parser from p

pub fn white_space<'b>(&'b self) -> WhiteSpace<'a, 'b, I>

Skips spaces and comments

pub fn symbol<'b>( &'b self, name: &'static str, ) -> Lex<'a, 'b, Expected<With<TokensCmp<fn(char, char) -> bool, Chars<'static>, I>, Value<I, &'static str>>, &'static str>, I>

Parses a symbol, lexing the stream if it is successful

pub fn identifier<'b>(&'b self) -> LexLanguageParser<'a, 'b, I, String>

Parses an identifier, failing if it parses something that is a reserved identifier

pub fn identifier_<'b>(&'b self) -> LanguageParser<'a, 'b, I, String>

pub fn range_identifier<'b>(&'b self) -> LexLanguageParser<'a, 'b, I, &'a str>

where I: RangeStream<Range = &'a str>,

Parses an identifier, failing if it parses something that is a reserved identifier

pub fn range_identifier_<'b>(&'b self) -> LanguageParser<'a, 'b, I, &'a str>

where I: RangeStream<Range = &'a str>,

pub fn reserved<'b>(&'b self, name: &'static str) -> Reserved<'a, 'b, I>

where I::Range: 'b,

Parses the reserved identifier name

pub fn op<'b>(&'b self) -> LexLanguageParser<'a, 'b, I, String>

Parses an operator, failing if it parses something that is a reserved operator

pub fn op_<'b>(&'b self) -> LanguageParser<'a, 'b, I, String>

pub fn range_op<'b>(&'b self) -> LexLanguageParser<'a, 'b, I, &'a str>

where I: RangeStream<Range = &'a str>,

Parses an identifier, failing if it parses something that is a reserved identifier

pub fn range_op_<'b>(&'b self) -> LanguageParser<'a, 'b, I, &'a str>

where I: RangeStream<Range = &'a str>,

pub fn reserved_op<'b>( &'b self, name: &'static str, ) -> Lex<'a, 'b, Reserved<'a, 'b, I>, I>

where I::Range: 'b,

Parses the reserved operator name

pub fn reserved_op_<'b>(&'b self, name: &'static str) -> Reserved<'a, 'b, I>

where I::Range: 'b,

pub fn char_literal<'b>(&'b self) -> LexLanguageParser<'a, 'b, I, char>

Parses a character literal taking escape sequences into account

pub fn char_literal_<'b>(&'b self) -> LanguageParser<'a, 'b, I, char>

pub fn string_literal<'b>(&'b self) -> LexLanguageParser<'a, 'b, I, String>

Parses a string literal taking character escapes into account

pub fn string_literal_<'b>(&'b self) -> LanguageParser<'a, 'b, I, String>

pub fn angles<'b, P>(&'b self, parser: P) -> BetweenChar<'a, 'b, P, I>

where P: Parser<I>, I::Range: 'b,

Parses p inside angle brackets < p >

pub fn braces<'b, P>(&'b self, parser: P) -> BetweenChar<'a, 'b, P, I>

where P: Parser<I>, I::Range: 'b,

Parses p inside braces { p }

pub fn brackets<'b, P>(&'b self, parser: P) -> BetweenChar<'a, 'b, P, I>

where P: Parser<I>, I::Range: 'b,

Parses p inside brackets [ p ]

pub fn parens<'b, P>(&'b self, parser: P) -> BetweenChar<'a, 'b, P, I>

where P: Parser<I>, I::Range: 'b,

Parses p inside parentheses ( p )

pub fn integer<'b>(&'b self) -> LexLanguageParser<'a, 'b, I, i64>

Parses an integer

pub fn integer_<'b>(&'b self) -> LanguageParser<'a, 'b, I, i64>

pub fn float<'b>(&'b self) -> LexLanguageParser<'a, 'b, I, f64>

Parses a floating point number

pub fn float_<'b>(&'b self) -> LanguageParser<'a, 'b, I, f64>