Struct combine_language::LanguageEnv

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

A type containing parsers for a specific language.

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

Parses a symbol, lexing the stream if it is successful

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

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

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) -> LanguageParser<'a, 'b, I, String>

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

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

Parses the reserved operator name

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

Parses a character literal taking escape sequences into account

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

Parses a string literal taking character escapes into account

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) -> LanguageParser<'a, 'b, I, i64>

Parses an integer

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

Parses a floating point number