Index

Modules: microparsec, microparsec/characters, microparsec/combinators, microparsec/internals, microparsec/primitives, microparsec/types.

API symbols

`$`:

• types: `$`[T](res: ParseResult[T]): string

`>>`:

• primitives: `>>`[S; T](parser0: Parser[S]; parser1: Parser[T]): Parser[T]

`<$`:

• primitives: `<$`[S, T](x: T; parser: Parser[S]): Parser[T]

`<*>`:

• microparsec: `<*>`[S, T](parser0: Parser[proc (i0: S): T]; parser1: Parser[S]): Parser[T]

`<*`:

• primitives: `<*`[T, S](parser0: Parser[T]; parser1: Parser[S]): Parser[T]

`<?>`:

• combinators: `<?>`[T](parser: Parser[T]; expected: string): Parser[T]

`<|>`:

• primitives: `<|>`[T](parser0, parser1: Parser[T]): Parser[T]

`*>`:

• primitives: `*>`[S, T](parser0: Parser[S]; parser1: Parser[T]): Parser[T]

anyChar:

• internals: anyChar

atEnd:

• types: atEnd(state: ParseState): bool

attempt:

• combinators: attempt[T](parser: Parser[T]): Parser[T]

between:

• combinators: between[R; S; T](open: Parser[R]; parser: Parser[T]; close: Parser[S]): Parser[T]

ch:

• internals: ch(c: char): Parser[char]

choice:

• combinators: choice[T](parsers: openArray[Parser[T]]): Parser[T]

compose:

• primitives: compose[R, S, T](f: R -> S; g: S -> T): R -> T

constant:

• primitives: constant[S, T](x: T): (S -> T)

count:

• combinators: count[T](n: int; parser: Parser[T]): Parser[seq[T]]

crlf:

• characters: crlf

debugParse:

• types: debugParse[T](parser: Parser[T]; x: auto; withPosition = false): string

digit:

• microparsec: digit

endOfLine:

• characters: endOfLine

eof:

• combinators: eof(state: ParseState): ParseResult[void]

fail:

• types: fail[T](res: ParseResult[auto]): ParseResult[T]
• types: fail[T](unexpected: string; expected: openArray[string]; state: ParseState; message = ""): ParseResult[T]

flatMap:

• primitives: flatMap[S, T](parser: Parser[S]; f: S -> Parser[T]): Parser[T]

getPosition:

• types: getPosition(state: ParseState): int

identity:

• primitives: identity[T](x: T): T

inClass:

• characters: inClass(cs: auto): (char -> bool)

letter:

• microparsec: letter

liftA2:

• primitives: liftA2[R, S, T](f: (R, S) -> T; parser0: Parser[R]; parser1: Parser[S]): Parser[ T]

many:

• primitives: many[T](parser: Parser[T]): Parser[seq[T]]

many1:

• combinators: many1[T](parser: Parser[T]): Parser[seq[T]]

manyTill:

• combinators: manyTill[S, T](parser: Parser[T]; endparser: Parser[S]): Parser[seq[T]]

map:

• microparsec: map[S, T](parser: Parser[S]; f: S -> T): Parser[T]

match:

• internals: match[T](parser: Parser[T]): Parser[(string, T)]

newline:

• characters: newline

newParseState:

• types: newParseState(s: Stream): ParseState
• types: newParseState(s: string): ParseState

noneOf:

• characters: noneOf(cs: auto): Parser[char]

notChar:

• internals: notChar(c: char): Parser[char]

notInClass:

• characters: notInClass(cs: auto): (char -> bool)

oneOf:

• characters: oneOf(cs: auto): Parser[char]

option:

• combinators: option[T](x: T; parser: Parser[T]): Parser[T]

optional:

• combinators: optional[T](parser: Parser[T]): Parser[void]

parse:

• types: parse[T; ](parser: Parser[T]; x: auto): ParseResult[T]
• types: parse[T](parser: Parser[T]; x: ParseState): ParseResult[T]

Parser:

• types: Parser

ParseResult:

• types: ParseResult

ParseState:

• types: ParseState

peekCh:

• internals: peekCh(state: ParseState): ParseResult[Option[char]]

peekChar:

• types: peekChar(state: ParseState): char

peekChF:

• internals: peekChF(state: ParseState): ParseResult[char]

pure:

• primitives: pure(): Parser[void]
• primitives: pure[T](x: T): Parser[T]

quoted:

• primitives: quoted(x: auto): string

readChar:

• types: readChar(state: ParseState): char

readLastStr:

• types: readLastStr(state: ParseState; length: int): string

readStr:

• types: readStr(state: ParseState; length: int): string

satisfy:

• internals: satisfy(p: char -> bool; expected: openArray[string] = []): Parser[char]

satisfyWith:

• internals: satisfyWith[T](f: char -> T; p: T -> bool; expected: openArray[string] = []): Parser[ T]

sepBy:

• combinators: sepBy[S; T](parser: Parser[T]; separator: Parser[S]): Parser[seq[T]]

sepBy1:

• combinators: sepBy1[S, T](parser: Parser[T]; separator: Parser[S]): Parser[seq[T]]

skip:

• internals: skip(p: char -> bool; expected: openArray[string] = []): Parser[void]

skipMany:

• combinators: skipMany[T](parser: Parser[T]): Parser[void]

skipMany1:

• combinators: skipMany1[T](parser: Parser[T]): Parser[void]

space:

• characters: space

spaces:

• characters: spaces

stepBack:

• types: stepBack(state: ParseState)

str:

• microparsec: str(s: string; t = ""): Parser[string]