Index

API symbols

`<*>`:

• easyparse: `<*>`[S, T, R](prec: Parser[S, proc (i0: T): R]; next: Parser[S, T]): Parser[S, R]

`<*`:

• easyparse: `<*`[S, T, R](p0: Parser[S, T]; p1: Parser[S, R]): Parser[S, T]

`<?>`:

• easyparse: `<?>`[S, T](parser: Parser[S, T]; name: string): Parser[S, T]

`<|>`:

• easyparse: `<|>`[S, T](p1: Parser[S, T]; p2: Parser[S, T]): Parser[S, T]

`*>`:

• easyparse: `*>`[S, T, R](p0: Parser[S, T]; p1: Parser[S, R]): Parser[S, R]

anyChar:

• easyparse: anyChar

canparse:

• easyparse: canparse[S, T](parser: Parser[S, T]): Parser[S, bool]

ch:

• easyparse: ch(ch: char): Parser[char, char]

choice:

• easyparse: choice[S, T](parsers: openArray[Parser[S, T]]): Parser[S, T]

debugParse:

• easyparse: debugParse[T](parser: Parser[char, T]; source: string): string

digit:

• easyparse: digit

Either:

• easyparse: Either

EitherKind:

• easyparse: EitherKind

eof:

• easyparse: eof[S](): Parser[S, Unit]

err:

• easyparse: err[S, T](R: type ParseResult[S, T]; x: auto): R:type
• easyparse: err[R; E; ](A: type Either[R, E]; x: auto): A:type

Error:

• ResultKind.Error

Exception:

• EitherKind.Exception

failure:

• easyparse: failure[S, R](): Parser[S, R]

fmap:

• easyparse: fmap[S, T, R](fn: T -> R; parser: Parser[S, T]): Parser[S, R]

ifthenelse:

• easyparse: ifthenelse[S, R](condition: Parser[S, bool]; iftrue: Parser[S, R]; iffalse: Parser[S, R]): Parser[S, R]

isErr:

• easyparse: isErr[S, T](res: ParseResult[S, T]): bool

isOk:

• easyparse: isOk[S, T](res: ParseResult[S, T]): bool

letter:

• easyparse: letter

liftA2:

• easyparse: liftA2[S, T, R, U](f: (T, R) -> U; p0: Parser[S, T]; p1: Parser[S, R]): Parser[ S, U]

many:

• easyparse: many[S, T](parser: Parser[S, T]): Parser[S, seq[T]]

many1:

• easyparse: many1[S, T](parser: Parser[S, T]): Parser[S, seq[T]]

newline:

• easyparse: newline(S: typedesc): S:type

next:

• easyparse: next[S](state: ParseState[S]): ParseState[S]

ok:

• easyparse: ok[S, T](R: type ParseResult[S, T]; state: ParseState[S]; value: T): R:type
• easyparse: ok[R; E; ](A: type Either[R, E]; x: auto): A:type

oneOf:

• easyparse: oneOf[S](possibilities: seq[S]): Parser[S, S]
• easyparse: oneOf(possibilities: string): Parser[char, char]

optional:

• easyparse: optional[S, T](parser: Parser[S, T]): Parser[S, Option[T]]

parse:

• easyparse: parse[S, T](parser: Parser[S, T]; source: seq[S]): Either[ParseOut[S, T], ParseError[S]]

parseApply:

• easyparse: parseApply(S: untyped; T: untyped; f: untyped; parsers: varargs[untyped]): untyped

ParseError:

• easyparse: ParseError

parseOrRaise:

• easyparse: parseOrRaise[T](parser: Parser[char, T]; source: string): T

ParseOut:

• easyparse: ParseOut

Parser:

• easyparse: Parser

ParseResult:

• easyparse: ParseResult

ParseState:

• easyparse: ParseState

ParsingError:

• easyparse: ParsingError

Position:

• easyparse: Position

pure:

• easyparse: pure[S, T](value: T): Parser[S, T]

Result:

• EitherKind.Result

ResultKind:

• easyparse: ResultKind

satisfy:

• easyparse: satisfy[S](predicate: S -> bool; expected: seq[string] = @[]): Parser[S, S]

sepBy:

• easyparse: sepBy[S, R, T](parser: Parser[S, R]; separator: Parser[S, T]): Parser[S, seq[R]]

sepBy1:

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

Success:

• ResultKind.Success

toSeq:

• easyparse: toSeq[S, T](parser: Parser[S, T]): Parser[S, seq[T]]

Unit:

• easyparse: Unit

unit:

• easyparse: unit