Index

API symbols

`$`:

• parsnim: `$`(parser: Parser): string
• parsnim: `$`(state: State): string

`and`:

• parsnim: `and`[T, R](parser, other: Parser[T, R]): Parser[T, R]

`not`:

• parsnim: `not`[T, R](parser: Parser[T, R]): Parser[T, R]

`or`:

• parsnim: `or`[T, R](parser, other: Parser[T, R]): Parser[T, R]

anything:

• parsnim: anything[T]()

at_least:

• parsnim: at_least(parser: Parser; n: int): auto

at_most:

• parsnim: at_most(parser: Parser; n: int): auto

describe:

• parsnim: describe(parser: var Parser; desc: string): Parser

Failure:

• ResultType.Failure

failure:

• parsnim: failure[T](start_index, end_index: int; expected: Stream[T]; description: string): Result[ T]
• parsnim: failure[T](start_index, end_index: int; description: string): Result[T]

many:

• parsnim: many(parser: Parser): Parser

map:

• parsnim: map[T, R, NR](parser: Parser[T, R]; item: NR): Parser[T, NR]
• parsnim: map[T, R, NR](parser: Parser[T, R]; map_fn: proc (x: R): NR): Parser[T, NR]
• parsnim: map[T, R, NR](parser: Parser[T, R]; map_fn: proc (x: seq[R]): seq[NR]): Parser[ T, NR]

Match:

• ResultType.Match

nothing:

• parsnim: nothing[T]()

optional:

• parsnim: optional(parser: Parser): auto

pad:

• parsnim: pad(parser: Parser[char, char]): Parser[char, char]
• parsnim: pad(parser: Parser[char, string]): Parser[char, string]

parse:

• parsnim: parse[char, R](parser: Parser[char, R]; stream: string): Stream[R]
• parsnim: parse[T, R](parser: Parser[T, R]; stream: Stream[T]): Stream[R]

ParseError:

• parsnim: ParseError

ParseFn:

• parsnim: ParseFn

parse_partial:

• parsnim: parse_partial[T, R](parser: Parser[T, R]; state: var State[T]): Result[R]
• parsnim: parse_partial[T, R](parser: Parser[T, R]; stream: Stream[T]): Result[R]

Parser:

• parsnim: Parser

Result:

• parsnim: Result

ResultType:

• parsnim: ResultType

skip:

• parsnim: skip[T, R](parser, other: Parser[T, R]): Parser[T, R]

space:

• parsnim: space(parser: Parser[char, char]): Parser[char, char]
• parsnim: space(parser: Parser[char, string]): Parser[char, string]

State:

• parsnim: State

str:

• parsnim: str[T](parser: Parser[T, char]): Parser[T, string]

Stream:

• parsnim: Stream

success:

• parsnim: success[T](start_index, end_index: int; value: Stream[T]; description: string): Result[ T]

tag:

• parsnim: tag[T, R](parser: Parser[T, R]; tag: string): Parser[T, R]

test_char:

• parsnim: test_char(test: char): Parser[char, char]

test_item:

• parsnim: test_item[T](test: T; description: string): auto

test_proc:

• parsnim: test_proc[T](test_proc_var: proc (x: T): bool; description: string): Parser[T, T]
• parsnim: test_proc[T](test_proc_var: proc (x: T): bool; description: string; expected: T): Parser[ T, T]

test_regex:

• parsnim: test_regex(pattern: Regex; description: string): Parser[char, string]

test_regex_string:

• parsnim: test_regex_string(pattern: Regex; description: string): Parser[string, string]

test_seq:

• parsnim: test_seq[T](test_seq: Stream[T]; description: string): Parser[T, T]

test_string:

• parsnim: test_string(test: string): auto

then:

• parsnim: then[T, R](parser, other: Parser[T, R]): Parser[T, R]

times:

• parsnim: times[T, R](parser: Parser[T, R]; min: int; max: int = -1): Parser[T, R]

to_bool:

• parsnim: to_bool(res: Result): bool

until:

• parsnim: until[T, R](self, parser: Parser[T, R]): Parser[T, R]