Index

Modules: nort, nort/base, nort/combinators, nort/helpers, nort/parser, nort/union, nort/utils.

API symbols

`$`:

• base: template `$`[T](comb: Combinator[T]; name: untyped): untyped

`&`:

• base: proc `&`(a, b: Void): Void

`*>`:

• combinators: proc `*>`[L, R](left: Combinator[L]; right: Combinator[R]): Combinator[R]

`*`:

• combinators: proc `*`[A: not tuple; B: tuple](left: Combinator[A]; right: Combinator[B]): Combinator[ B]
• combinators: proc `*`[A: tuple; B: not tuple](left: Combinator[A]; right: Combinator[B]): Combinator[ A]
• combinators: proc `*`[A: tuple; B: tuple](left: Combinator[A]; right: Combinator[B]): auto
• combinators: proc `*`[T](left: Combinator[Chain[T]]; right: Combinator[T]): Combinator[Chain[T]]
• combinators: proc `*`[T: not tuple](left: Combinator[T]; right: Combinator[Void]): Combinator[T]
• combinators: proc `*`[T](comb: Combinator[T]): Combinator[Chain[T]]
• combinators: proc `*`[T](left: Combinator[T]; right: Combinator[Chain[T]]): Combinator[Chain[T]]
• combinators: proc `*`[T](left: Combinator[Void]; right: Combinator[T]): Combinator[T]
• combinators: proc `*`(left: Combinator[Void]; right: Combinator[Void]): Combinator[Void]
• combinators: template `*`[A, B](left: Combinator[A]; right: Combinator[B]): Combinator[Void]

`+`:

• combinators: proc `+`[T](comb: Combinator[T]): Combinator[Chain[T]]

`-`:

• combinators: proc `-`(comb: Combinator): Combinator[Void]

`<*>`:

• combinators: proc `<*>`[L, R](left: Combinator[L]; right: Combinator[R]): Combinator[ tuple[left: L, right: R]]

`<*`:

• combinators: proc `<*`[L, R](left: Combinator[L]; right: Combinator[R]): Combinator[L]

`?`:

• combinators: proc `?`[T](comb: Combinator[T]): Combinator[Option[T]]

`case`:

• union: macro `case`(u: UnionDiscriminator): untyped

`not`:

• combinators: proc `not`(comb: Combinator): Combinator[Void]

`|`:

• combinators: proc `|`[L, R](left: Combinator[L]; right: Combinator[R]): Combinator[Void]
• combinators: proc `|`[T](left, right: Combinator[T]): Combinator[T]

access:

• utils: macro access(a: untyped; name: static[string]): untyped

add:

• base: proc add(coll: var Chain[Void]; val: Void)

any:

• combinators: proc any[T: tuple](options: T): Combinator[mapAny(T)]
• combinators: proc any[T](options: varargs[Combinator[T]]): Combinator[T]

between:

• combinators: proc between[T, L, R](comb: Combinator[T]; left: Combinator[L]; right: Combinator[R]): Combinator[ T]

bindTo:

• base: proc bindTo[T; R: tuple](comb: Combinator[T]): Combinator[R]
• base: proc bindTo[T, R](comb: Combinator[Void])

branch:

• union: proc branch[U](union: U): UnionDiscriminator[U]

Chain:

• base: type Chain

chainl:

• combinators: proc chainl[T, S](comb: Combinator[T]; sep: Combinator[S]; combine: Reducer[T, S]): Combinator[ T]

chainr:

• combinators: proc chainr[T, S](comb: Combinator[T]; sep: Combinator[S]; combine: Reducer[T, S]): Combinator[ T]

Combinator:

• base: object Combinator

continuesWith:

• parser: proc continuesWith(p: Parser; token: string): Option[(Parser, string)]

digit:

• combinators: proc digit(): Combinator[int]

dot:

• combinators: proc dot(): Combinator[char]

e:

• combinators: proc e[T](val: set[T]): Combinator[T]
• combinators: proc e[T](val: T): Combinator[T]

eat:

• parser: proc eat(p: Parser): Option[(Parser, char)]

eof:

• parser: proc eof(p: Parser): bool

expect:

• combinators: proc expect(input: char): Combinator[char]
• combinators: proc expect[T](values: HashSet[T]): Combinator[T]
• combinators: proc expect(expect: set[char]): Combinator[char]
• combinators: proc expect(expect: string): Combinator[string]
• combinators: proc expect[T: enum](e: typedesc[T]): Combinator[T]

Explorer:

• base: type Explorer

failure:

• combinators: proc failure(): Combinator[Void]

filter:

• combinators: proc filter[T](comb: Combinator[T]; check: proc (val: T): bool): Combinator[T]

fin:

• combinators: proc fin(): Combinator[Void]

initCombinator:

• base: proc initCombinator[T](factory: proc (): Explorer[T]): Combinator[T]

just:

• combinators: proc just[T](comb: Combinator[T]): Combinator[T]

lazy:

• base: proc lazy[T](comb: proc (): Combinator[T]): Combinator[T]

len:

• parser: proc len(p: Parser): int

listOf:

• combinators: proc listOf[T](comb: Combinator[T]; sep: Combinator): Combinator[T]

makeIdent:

• utils: macro makeIdent(name: static[string]): untyped

map:

• combinators: proc map[T, R](comb: Combinator[T]; op: proc (inp: T): R): Combinator[R]
• combinators: proc map[R](mapping: openArray[(Combinator[Void], R)]): Combinator[R]

match:

• base: proc match[T](comb: Combinator[T]; data: string): Option[T]

merge:

• utils: macro merge(a: typedesc[tuple]; b: typedesc[tuple]): typedesc
• utils: template merge(a: typedesc[not tuple]; b: typedesc[tuple]): typedesc
• utils: template merge(a: typedesc[tuple]; b: typedesc[not tuple]): typedesc

nl:

• helpers: let nl

occurs:

• combinators: proc occurs[T](comb: Combinator[T]): Combinator[bool]

Parser:

• parser: object Parser

ParseResult:

• base: tuple ParseResult

ParseTree:

• base: type ParseTree

peek:

• parser: proc peek(p: Parser): Option[char]

public:

• utils: proc public(ident: NimNode): NimNode

Reducer:

• combinators: type Reducer

results:

• base: iterator results[T](comb: Combinator[T]; parser: Parser): ParseResult[T]

sep:

• combinators: proc sep[T](comb: Combinator[T]; sep: Combinator): Combinator[seq[T]]

skip:

• parser: proc skip(p: Parser; n: int): Parser

succeed:

• combinators: proc succeed[T](value: T): Combinator[T]

test:

• base: proc test[T](comb: Combinator[T]; data: sink string): bool

trace:

• base: proc trace[T](comb: Combinator[T]): Combinator[T]

UnionDiscriminator:

• union: object UnionDiscriminator

until:

• combinators: proc until[T](comb: Combinator[T]; target: Combinator): Combinator[Chain[T]]

untilIncl:

• combinators: proc untilIncl[T](comb: Combinator[T]; target: Combinator): Combinator[Chain[T]]

Void:

• base: object Void

ws:

• helpers: let ws

yieldfrom:

• utils: template yieldfrom[T](iter: iterable[T])