Move delimiter parser to internals

src/org/org_text_delimiter.nim

@@ -10,13 +10,6 @@ import ../parser/parser_internals
 import ../parser/parser_types
 import ../parser/builder_api
 
-let parseBetweenDelimiter* = proc(start: (Parser -> ParserResult), stop: (Parser -> ParserResult)): (Parser -> ParserResult) {.closure.} =
-  ignore(start) +
-  anyUntil(stop + whitespace) +
-  ignore(start)
-
-let parseBetweenPair* = proc(delimiterParser: (Parser -> ParserResult)): (Parser -> ParserResult) {.closure.} =
-  parseBetweenDelimiter(delimiterParser, delimiterParser)
 
 let boldParser* = parseBetweenPair(ch('*'))
 let italicParser* = parseBetweenPair(ch('/'))

src/parser/parser_internals.nim

@@ -87,8 +87,7 @@ func str*(s: string): (Parser -> ParserResult) {.inline.} =
       p = p.flatMap(ch(c))
     return p
 
-
-# -- Parsing Helper Functions
+# -- Parsing API
 
 func optional*(parserFn: Parser -> ParserResult): (Parser -> ParserResult) {.inline.} =
   ## Parse characters and ignore failure
@@ -187,33 +186,12 @@ proc whitespace*(parser: Parser): ParserResult =
   whitespaceParser(parser)
   .mapErr((x: ParserError) => x.setErrorExpectedField("Whitespace"))
 
-# when isMainModule:
-#   proc getTokens(x: ParserResult): seq[string] =
-#     x.foldTokens(
-#       proc(err: ParserError): seq[string] =
-#         echo err
-#         @[],
-#       proc(xs: seq[ParserToken]): seq[string] = xs.map((x: ParserToken) => x.tokenStringValue()),
-#     )
+# -- Parsing Helpers
 
-#   proc testParser(x: string, ps: seq[Parser -> ParserResult]): seq[string] =
-#     initParserResult(x).parseSeq(ps).getTokens()
+let parseBetweenDelimiter* = proc(start: (Parser -> ParserResult), stop: (Parser -> ParserResult)): (Parser -> ParserResult) {.closure.} =
+  ignore(start) +
+  anyUntil(stop + whitespace) +
+  ignore(start)
 
-#   let optionalPrefixParser = @[
-#     optional(ch('_')),
-#     str("ABC")
-#   ]
-#   assert: "_ABC".testParser(optionalPrefixParser) == @["_", "A", "B", "C"]
-#   assert: "ABC".testParser(optionalPrefixParser) == @["A", "B", "C"]
-
-#   let andParser = @[
-#     (ch('A') + ch('B')),
-#     ch('C'),
-#   ]
-#   assert: "ABC".testParser(andParser) == @["A", "B", "C"]
-
-#   let newlineParserTest = @[
-#     str("ABC"),
-#     newline
-#   ]
-#   assert "ABC\n".testParser(newlineParserTest) == @["A", "B", "C", "\n"]
+let parseBetweenPair* = proc(delimiterParser: (Parser -> ParserResult)): (Parser -> ParserResult) {.closure.} =
+  parseBetweenDelimiter(delimiterParser, delimiterParser)