Use proc, fn and const dont work

src_v2/parser/parser_internals.nim

@@ -14,12 +14,12 @@ import ./parser_types
 
 # -- Types
 
-type parserFnT = proc(t0: Parser): ParserResult {.nosideeffect.}
+type parserFnT = proc(t0: Parser): ParserResult
 
 # -- Utilities
 
-func lookBack*(count: int): (parserFnT) =
-  return func(parser: Parser): ParserResult =
+proc lookBack*(count: int): (parserFnT) =
+  return proc(parser: Parser): ParserResult =
     let state = parser.state
     let newIndex = state.position - 1
 
@@ -32,10 +32,10 @@ func lookBack*(count: int): (parserFnT) =
       tokens: parser.tokens,
     ).ok()
 
-# -- Parsing Functions
+# -- Parsing Proctions
 
-func ch*(expectedChars: set[char]): parserFnT {.inline.} =
-  return func(parser: Parser): ParserResult =
+proc ch*(expectedChars: set[char]): parserFnT {.inline.} =
+  return proc(parser: Parser): ParserResult =
     let state = parser.state
     let newIndex = state.position + 1
 
@@ -66,8 +66,8 @@ func ch*(expectedChars: set[char]): parserFnT {.inline.} =
           parser: parser,
         ))
 
-func ch*(expectedChar: char): parserFnT {.inline.} =
-  return func(parser: Parser): ParserResult =
+proc ch*(expectedChar: char): parserFnT {.inline.} =
+  return proc(parser: Parser): ParserResult =
     let state = parser.state
     let newIndex = state.position + 1
 
@@ -98,10 +98,10 @@ func ch*(expectedChar: char): parserFnT {.inline.} =
           parser: parser,
         ))
 
-const anyCh* = ch(AllChars)
+let anyCh* = ch(AllChars)
 
-func str*(s: string): parserFnT {.inline.} =
-  return func(parser: Parser): ParserResult =
+proc str*(s: string): parserFnT {.inline.} =
+  return proc(parser: Parser): ParserResult =
     var p = parser.ok()
     for c in s.items:
       p = p.flatMap(ch(c))
@@ -109,9 +109,9 @@ func str*(s: string): parserFnT {.inline.} =
 
 # -- Parsing API
 
-func optional*(parserFn: parserFnT): parserFnT {.inline.} =
+proc optional*(parserFn: parserFnT): parserFnT {.inline.} =
   ## Parse characters and ignore failure
-  return func(parser: Parser): ParserResult =
+  return proc(parser: Parser): ParserResult =
     let newParser = parserFn(parser)
 
     if newParser.isOk():
@@ -119,18 +119,18 @@ func optional*(parserFn: parserFnT): parserFnT {.inline.} =
     else:
       parser.ok()
 
-func ignore*(parserFn: parserFnT): parserFnT {.inline.} =
+proc ignore*(parserFn: parserFnT): parserFnT {.inline.} =
   ## Parse characters but throw success tokens away
-  return func(parser: Parser): ParserResult =
+  return proc(parser: Parser): ParserResult =
     return parserFn(parser)
     .map((x: Parser) => Parser(
       state: x.state,
       tokens: parser.tokens,
     ))
 
-func manyUntilPerformant*(acceptFn: parserFnT, stopFn: parserFnT): parserFnT {.inline.} =
+proc manyUntilPerformant*(acceptFn: parserFnT, stopFn: parserFnT): parserFnT {.inline.} =
   ## Parse characters but throw success tokens away
-  return func(parser: Parser): ParserResult =
+  return proc(parser: Parser): ParserResult =
     let startPosition = parser.state.position
     var res: ParserResult = parser.ok()
 
@@ -151,22 +151,22 @@ func manyUntilPerformant*(acceptFn: parserFnT, stopFn: parserFnT): parserFnT {.i
       ]
     ))
 
-func anyUntilPerformant*(stopFn: parserFnT): parserFnT {.inline.} =
+proc anyUntilPerformant*(stopFn: parserFnT): parserFnT {.inline.} =
   manyUntilPerformant(ch(AllChars), stopFn)
 
-func manyUntil*(acceptFn: parserFnT, stopFn: parserFnT): parserFnT {.inline.} =
+proc manyUntil*(acceptFn: parserFnT, stopFn: parserFnT): parserFnT {.inline.} =
   ## Parse characters but throw success tokens away
-  return func(parser: Parser): ParserResult =
+  return proc(parser: Parser): ParserResult =
     var res: ParserResult = parser.ok()
     while res.isOk() and res.flatMap(stopFn).isErr():
       res = res.flatMap(acceptFn)
     return res
 
-func anyUntil*(stopFn: parserFnT): parserFnT {.inline.} =
+proc anyUntil*(stopFn: parserFnT): parserFnT {.inline.} =
   manyUntil(anyCh, stopFn)
 
-func choice*(parsers: seq[parserFnT]): parserFnT {.inline} =
-  return func(parser: Parser): ParserResult {.closure, nosideeffect.} =
+proc choice*(parsers: seq[parserFnT]): parserFnT {.inline} =
+  return proc(parser: Parser): ParserResult {.closure.} =
     var errors: seq[ParserResult] = newSeq[ParserResult]()
     var found = Nothing[ParserResult]()
 
@@ -181,7 +181,7 @@ func choice*(parsers: seq[parserFnT]): parserFnT {.inline} =
 
     return found
     .fold(
-      func(): ParserResult =
+      proc(): ParserResult =
         let prettyErrors = errors.map((x: ParserResult) => x.error().expected)
         err(ParserError(
           kind: choiceMismatchErr,
@@ -190,21 +190,21 @@ func choice*(parsers: seq[parserFnT]): parserFnT {.inline} =
           unexpected: errors[0].error().unexpected,
           parser: parser,
         )),
-      func(x: ParserResult): ParserResult = x,
+      proc(x: ParserResult): ParserResult = x,
     )
 
 
-func `+`*(parserFnA: parserFnT, parserFnB: parserFnT): parserFnT {.inline.} =
+proc `+`*(parserFnA: parserFnT, parserFnB: parserFnT): parserFnT {.inline.} =
   ## Parse characters and ignore failure
-  return func(parser: Parser): ParserResult =
+  return proc(parser: Parser): ParserResult =
     parserFnA(parser).flatMap(parserFnB)
 
-func parseSeq*(parser: ParserResult, xs: seq[parserFnT]): ParserResult =
+proc parseSeq*(parser: ParserResult, xs: seq[parserFnT]): ParserResult {.inline.} =
   xs.foldl(a.flatMap(b), parser)
 
 # -- Parsing Aliases
 
-func endOfStream*(parser: Parser): ParserResult =
+proc endOfStream*(parser: Parser): ParserResult =
   let index = parser.state.position + 1
   if index == parser.state.stream.len:
     ok(parser)
@@ -216,27 +216,40 @@ func endOfStream*(parser: Parser): ParserResult =
       parser: parser,
     ))
 
-const newlineParser = choice(@[
+let newlineParser = choice(@[
   ch(NewLines),
   endOfStream,
 ])
 
-func newline*(parser: Parser): ParserResult =
+proc newline*(parser: Parser): ParserResult =
   newlineParser(parser)
   .mapErr((x: ParserError) => x.setErrorExpectedField("Newline"))
 
-const whitespaceParser = choice(@[
+let whitespaceParser = choice(@[
   ch(Whitespace),
   newlineParser,
 ])
-func whitespace*(parser: Parser): ParserResult =
+proc whitespace*(parser: Parser): ParserResult =
   whitespaceParser(parser)
   .mapErr((x: ParserError) => x.setErrorExpectedField("Whitespace"))
 
 # -- Parsing Helpers
 
-const parseBetweenDelimiter* = func(start: parserFnT, stop: parserFnT): parserFnT {.closure.} =
+let parseBetweenDelimiter* = proc(start: parserFnT, stop: parserFnT): parserFnT {.closure.} =
   ignore(start) + anyUntil(stop + whitespace) + ignore(start)
 
-const parseBetweenPair* = func(delimiterParser: parserFnT): parserFnT {.closure.} =
+let parseBetweenPair* = proc(delimiterParser: parserFnT): parserFnT {.closure.} =
   parseBetweenDelimiter(delimiterParser, delimiterParser)
+
+# -- Tests
+
+when isMainModule:
+  let test1 = initParserResult("123")
+
+  let ch1 = ch('1')
+  let chDigits = @[ch(Digits)]
+
+  # echo type ch1
+  # echo test1.flatMap((x: Parser) => ParserResult.ok(x))
+  echo test1.flatMap(newlineParser)
+  # .flatMap(ch1)