Struct combine_language::LanguageEnv

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

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.

Methods

impl<'a, I> LanguageEnv<'a, I> where
    I: Stream<Item = char>,
    I::Error: ParseError<I::Item, 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<Input = I, Output = char> + 'a,
    B: Parser<Input = I, Output = char> + 'a,
    C: Parser<Input = I, Output = char> + 'a,
    D: Parser<Input = I, Output = char> + 'a,
    E: Parser<Input = I, Output = ()> + 'a,
    F: Parser<Input = I, Output = ()> + 'a,
    G: Parser<Input = I, Output = ()> + 'a, 

Constructs a new parser from a language defintion

pub fn lex<'b, P>(&'b self, p: P) -> Lex<'a, 'b, P> where
    P: Parser<Input = 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, 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>> 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> where
    P: Parser<Input = I>,
    I::Range: 'b, 

Parses p inside angle brackets < p >

pub fn braces<'b, P>(&'b self, parser: P) -> BetweenChar<'a, 'b, P> where
    P: Parser<Input = I>,
    I::Range: 'b, 

Parses p inside braces { p }

pub fn brackets<'b, P>(&'b self, parser: P) -> BetweenChar<'a, 'b, P> where
    P: Parser<Input = I>,
    I::Range: 'b, 

Parses p inside brackets [ p ]

pub fn parens<'b, P>(&'b self, parser: P) -> BetweenChar<'a, 'b, P> where
    P: Parser<Input = 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>