src/parsnim

    Dark Mode
Search:
Group by:
  Source   Edit

Types

ParseError = object of ValueError
  Source   Edit 
ParseFn[T; R] = proc (s: var State[T]): Result[R]
function defined to manipulate State for the next parser and return a result   Source   Edit 
Parser[T; R] = object
  fn*: ParseFn[T, R]
  description*: string
central object to wrap all ParseFns in   Source   Edit 
Result[T] = object of RootObj
  kind*: ResultType          ## states whether the result is a `Match` or `Failure`
  value*: Stream[T]          ## `Parser`s translate from one stream to another hence result values are `Stream`s
  start_index*, end_index*: int ## start and end indices for the value/expected
  tag*: seq[string]          ## an optional seq of strings that can be used to mark results for further processing
  description*: string       ## describes what the value would represent. used when erroring on failed parsing
  expected*: Stream[T]       ## for failures, what value wanted to be. used when erroring on failed parsing
Result objects are returned by all parsers   Source   Edit 
ResultType = enum
  Match, Failure
  Source   Edit 
State[T] = object
  index*: int
  stream*: Stream[T]
object passed to all parsers to track position and the stream being parsed   Source   Edit 
Stream[T] = seq[T]
Stream is an alias for seq[T]   Source   Edit

Procs

proc `$`(parser: Parser): string
  Source   Edit 
proc `$`(state: State): string
  Source   Edit 
proc `and`[T, R](parser, other: Parser[T, R]): Parser[T, R]
parser and other must both match at the current position in the stream
let p = test_proc(proc(c: char): auto = parseInt($c)>2, "greater than 2") and test_proc(proc(c: char): auto = parseInt($c)<= 10, "less than or equal to 10")
echo p
echo p.parse("4")
# <Parser: greater than 2 and less than or equal to 10>
# @['4']
p.parse("1")
# Error: unhandled exception: failed to parse with error: Expected `greater than 2` got @['1'] @ 0:1 [ParseError]
  Source   Edit 
proc `not`[T, R](parser: Parser[T, R]): Parser[T, R]
inverts a Result so that a failure is instead a match and vice-versa
let p = not test_char('c')
echo p
echo p.parse("p")
# <Parser: not char c>
# @['p']
  Source   Edit 
proc `or`[T, R](parser, other: Parser[T, R]): Parser[T, R]
parser or other must match
let p = test_char('c') or test_char('p')
echo p
echo p.parse("p")
# <Parser: char c or char p>
# @['p']
  Source   Edit 
proc anything[T]()
  Source   Edit 
proc at_least(parser: Parser; n: int): auto
finds parser at least n times   Source   Edit 
proc at_most(parser: Parser; n: int): auto
finds parser up to n times   Source   Edit 
proc describe(parser: var Parser; desc: string): Parser
describe a parser   Source   Edit 
proc failure[T](start_index, end_index: int; description: string): Result[T]
function to generate Failure Results without an expected value   Source   Edit 
proc failure[T](start_index, end_index: int; expected: Stream[T];
                description: string): Result[T]
function to generate Failure Results with an expected value   Source   Edit 
proc many(parser: Parser): Parser
finds parser until it doesn't
let t = (test_char('c')).many().then(test_char('p'))
echo t
echo t.parse("ccccp")
# <Parser: char c many times then char p>
# @['c', 'c', 'c', 'c', 'p']
  Source   Edit 
proc map[T, R, NR](parser: Parser[T, R]; item: NR): Parser[T, NR]
takes a parser that goes from Stream[T]->Stream[R] and transforms it to Stream[T]->Stream[NR]   Source   Edit 
proc map[T, R, NR](parser: Parser[T, R]; map_fn: proc (x: R): NR): Parser[T, NR]
takes a parser that goes from Stream[T]->Stream[R] and transforms it to Stream[T]->Stream[NR]   Source   Edit 
proc map[T, R, NR](parser: Parser[T, R]; map_fn: proc (x: seq[R]): seq[NR]): Parser[
    T, NR]
takes a parser that goes from Stream[T]->Stream[R] and transforms it to Stream[T]->Stream[NR]   Source   Edit 
proc nothing[T]()
  Source   Edit 
proc optional(parser: Parser): auto
tries to find parser and if not continues   Source   Edit 
proc pad(parser: Parser[char, char]): Parser[char, char] {.
    ...raises: [ValueError, RegexError], tags: [].}
optional whitespace
echo test_char('c').pad.parse("c    ")
# @['c']
  Source   Edit 
proc pad(parser: Parser[char, string]): Parser[char, string] {.
    ...raises: [ValueError, RegexError], tags: [].}
optional whitespace
echo test_string("hello").pad.parse("hello    ")
# @["hello"]
  Source   Edit 
proc parse[char, R](parser: Parser[char, R]; stream: string): Stream[R]
run a parser on a stream that is a string   Source   Edit 
proc parse[T, R](parser: Parser[T, R]; stream: Stream[T]): Stream[R]
run a parser on a stream   Source   Edit 
proc parse_partial[T, R](parser: Parser[T, R]; state: var State[T]): Result[R]
  Source   Edit 
proc parse_partial[T, R](parser: Parser[T, R]; stream: Stream[T]): Result[R]
  Source   Edit 
proc skip[T, R](parser, other: Parser[T, R]): Parser[T, R]
parses parser then other but ignores other result   Source   Edit 
proc space(parser: Parser[char, char]): Parser[char, char] {.
    ...raises: [ValueError], tags: [].}
optional whitespace
echo test_char('c').space.parse("c ")
# @['c']
  Source   Edit 
proc space(parser: Parser[char, string]): Parser[char, string] {.
    ...raises: [ValueError], tags: [].}
optional whitespace
let p = test_string("9").space
echo p.parse("9")
# @["9"]
  Source   Edit 
proc str[T](parser: Parser[T, char]): Parser[T, string]
  Source   Edit 
proc success[T](start_index, end_index: int; value: Stream[T];
                description: string): Result[T]
function to generate Match Results   Source   Edit 
proc tag[T, R](parser: Parser[T, R]; tag: string): Parser[T, R]
creates a parser that tags parser results   Source   Edit 
proc test_char(test: char): Parser[char, char] {....raises: [], tags: [].}
test if a char is next in the stream (usually a string for char test)   Source   Edit 
proc test_item[T](test: T; description: string): auto
test if a single test item is next in the stream   Source   Edit 
proc test_proc[T](test_proc_var: proc (x: T): bool; description: string): Parser[
    T, T]
tests a procedure against the next value in the stream
let p = test_proc(proc(c: char): auto = parseInt($c)>2, "greater than 2")
echo p
echo p.parse("4")
# <Parser: greater than 2>
# @['4']
  Source   Edit 
proc test_proc[T](test_proc_var: proc (x: T): bool; description: string;
                  expected: T): Parser[T, T]
tests a procedure against the next value in the stream
let p = test_proc(proc(c: char): auto = c== '4', "the character '4'", "'4'")
echo p
echo p.parse("4")
# <Parser: the character '4'>
# @['4']
  Source   Edit 
proc test_regex(pattern: Regex; description: string): Parser[char, string] {.
    ...raises: [ValueError], tags: [].}
tests if a regex pattern is next in a stream
let r = test_regex(re"[a-zA-Z_][a-zA-Z0-9_]*", "identifier")
echo r
echo r.parse("_hello1984")
# <Parser: regex identifier>
# @["_hello1984"]
  Source   Edit 
proc test_regex_string(pattern: Regex; description: string): Parser[string,
    string] {....raises: [], tags: [].}
  Source   Edit 
proc test_seq[T](test_seq: Stream[T]; description: string): Parser[T, T]
tests if the test_seq is the next sequence of the state's stream

let t = test_seq("abc".to_seq, "alphabet") echo t echo t.parse("abc") # <Parser: alphabet> # @['a', 'b', 'c']

  Source   Edit 
proc test_string(test: string): auto {....raises: [ValueError], tags: [].}
tests if a string is next in a stream (special case of test_seq)

let t = test_string("abc") echo t echo t.parse("abc") # <Parser: string abc> # @["abc"]

  Source   Edit 
proc then[T, R](parser, other: Parser[T, R]): Parser[T, R]
parses parser then other and rolls them together

let t = test_char('c').then(test_char('p')) echo t echo t.parse("cp") # <Parser: char c then char p> # @['c', 'p']

  Source   Edit 
proc times[T, R](parser: Parser[T, R]; min: int; max: int = -1): Parser[T, R]
looks for parser to repeat >=min and <=max times
let t = (not test_char('c')).times(3)
echo t
echo t.parse("abd")
# <Parser: not char c 3 times>
# @['a', 'b', 'd']
  Source   Edit 
proc until[T, R](self, parser: Parser[T, R]): Parser[T, R]
looks for the current parser self until parser matches
let p = (test_char('c')).until(test_char('p'))
echo p
echo p.parse("ccccp")
# <Parser: char c until not char c>
# @['c', 'c', 'c', 'c', 'p']
  Source   Edit

Converters

converter to_bool(res: Result): bool
Results are truthy/falsey   Source   Edit

Made with Nim. Generated: 2022-09-07 01:13:05 UTC