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>, 

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

fn lex<'b, P>(&'b self, p: P) -> Lex<'a, 'b, P> where
    P: Parser<Input = I> + 'b, 

Creates a lexing parser from p

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

Skips spaces and comments

fn symbol<'b>(&'b self, name: &'static str) -> Lex<'a, 'b, Str<I>>

Parses a symbol, lexing the stream if it is successful

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

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

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

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

fn range_identifier_<'b>(&'b self) -> LanguageParser<'a, 'b, I, &'a str> where
    I: RangeStream<Range = &'a str>, 

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

Parses the reserved identifier name

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

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

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

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

fn range_op_<'b>(&'b self) -> LanguageParser<'a, 'b, I, &'a str> where
    I: RangeStream<Range = &'a str>, 

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

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

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

Parses a character literal taking escape sequences into account

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

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

Parses a string literal taking character escapes into account

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

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 >

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 }

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 ]

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 )

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

Parses an integer

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

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

Parses a floating point number

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