WIP Working seq parsing

src/org/org_block_heading.nim

@@ -49,6 +49,7 @@ let parseHeadingText = @[
 #   # builder.level = token.tokenStringValue().len
 #   token
 
+
 let buildStars = func(tokens: seq[ParserToken], org: OrgBlock): OrgBlock {.closure.}=
   org.level = tokens.len
   org
@@ -101,31 +102,53 @@ let headingParser = choice(@[
   endOfStream,
 ])
 
+let newlineParser: seq[Parser -> ParserResult] = @[newline + newline]
+
+let buildNewline = func(tokens: seq[ParserToken], org: OrgBlock): OrgBlock {.closure.} =
+  OrgBlock(
+    kind: orgNewline
+  )
+
+proc concatOrgBlock(xs: seq[OrgBlock], ys: seq[OrgBlock]): seq[OrgBlock] = xs & ys
+
+let contentParsersSeq: seq[tuple[
+  parsers: seq[Parser -> ParserResult],
+  tokenFoldFn: (seq[ParserToken], OrgBlock) -> OrgBlock,
+  ignoreEmpty: bool,
+  # concatFn: (seq[OrgBlock], seq[OrgBlock]) -> seq[OrgBlock],
+]] = @[
+  (newlineParser, buildNewline, false),
+  # (newlineParser, buildNewline, false),
+]
+
 proc parseHeadlineChildren(builder: OrgBuilder): OrgBuilderResult =
   var headingBlock = builder.tree[0]
 
-  var parserAcc: ParserResult = ParserResult.ok(builder.parser)
+  var builderAcc: OrgBuilderResult = OrgBuilderResult.ok(builder)
 
-  # echo parserAcc
+  while builderAcc.isOk() and builderAcc.tryParser(headingParser).isErr():
+    builderAcc = builderAcc
+      .applyParsersSeqToSeq(
+        contentParsersSeq
+      )
 
-  while parserAcc.isOk() and parserAcc.flatMap(headingParser).isErr():
+  builderAcc
-    parserAcc = parserAcc.flatMap(anyCh)
 
-  let content = parserAcc.foldTokens(
+  # let content = builderAcc.fold(
-    (err) => "",
+  #   (_err) => "",
-    (xs: seq[ParserToken]) => xs.tokensToString(),
+  #   (builder: OrgBuilder) => builder.tree,
-  )
+  # )
-  headingBlock.content = content
+  # headingBlock.content = content
 
-  let res = parserAcc.fold(
+  # let res = builderAcc.fold(
-    (err) => OrgBuilderResult.err((builder, "Could not parse content")),
+  #   (_err) => OrgBuilderResult.err((builder, "Could not parse content")),
-    (parser: Parser) => OrgBuilderResult.ok((
+  #   (builder: OrgBuilder) => OrgBuilderResult.ok((
-        parser: parser.emptyTokens(),
+  #       parser: builder.parser.emptyTokens(),
-        tree: @[headingBlock],
+  #       tree: @[headingBlock],
-    ))
+  #   ))
-  )
+  # )
 
-  res
+  # res
 
 proc makeOrg*(x: string): OrgBuilderResult =
   var acc = initOrgBuilder(x)

src/parser/parser_types.nim

@@ -199,6 +199,38 @@ proc applyParsersToSingle*[T](
     )
   )
 
+## TODO Implement applyParsersSeqToSingle with this function by forming the concatFn
+proc applyParsersToSeq*[T](
+  builder: Builder[T],
+  parsers: seq[Parser -> ParserResult],
+  tokenFoldFn: (seq[ParserToken], T) -> T,
+  # concatFn = `&`,
+  optional = false,
+  isFirst: bool,
+): BuilderResult[T] =
+  # Apply the current parsing functions and convert to text tokens wrapped in ParserResult
+  let newParser = ParserResult.ok(Parser(
+    state: builder[0].state,
+    tokens: @[]
+  ))
+  .parseSeq(parsers)
+
+  newParser
+  .foldTokens(
+    (err: ParserError) => BuilderResult[T].err((builder, "foo")),
+    (newTokens: seq[ParserToken]) => (
+      if optional and newTokens.len == 0:
+        BuilderResult[T].ok(builder)
+      else:
+        BuilderResult[T].ok(
+          builder.initBuilder(
+            newParser.unsafeGet(),
+            builder.tree & builder.tree
+          )
+        )
+    )
+  )
+
 proc applyParsersSeqToSingle*[T](
   builderResult: BuilderResult[T],
   initT: T,
@@ -220,6 +252,27 @@ proc applyParsersSeqToSingle*[T](
       builderResult
     )
 
+proc applyParsersSeqToSeq*[T](
+  builderResult: BuilderResult[T],
+  xs: seq[tuple[
+    parsers: seq[Parser -> ParserResult],
+    tokenFoldFn: (seq[ParserToken], T) -> T,
+    ignoreEmpty: bool,
+    # concatFn: (seq[T], seq[T]) -> seq[T],
+  ]],
+): BuilderResult[T] =
+    xs.foldl(
+      a.flatMap((builder: Builder[T]) => applyParsersToSeq(
+        builder = builder,
+        parsers = b.parsers,
+        tokenFoldFn = b.tokenFoldFn,
+        optional = b.ignoreEmpty,
+        isFirst = a == builderResult,
+        # concatFn = concatFn
+      )),
+      builderResult
+    )
+
 proc applyParsers*[T](
   builder: Builder[T],
   parsers: seq[Parser -> ParserResult],
@@ -260,6 +313,20 @@ proc foldBuilder*[T, T2](
     let err = builderResult.error()
     onError(err[1])
 
+# proc parseBuildOr*[T](
+#   ## Checks
+#   builderResult: BuilderResult[T],
+#   builders: seq[tuple[
+#     parsers: seq[Parser -> ParserResult],
+#     tokenFoldFn: (seq[ParserToken], T) -> T,
+#   ]],
+#   defaultBuilder: tuple[
+#     defaultParser: Parser -> ParserResult,
+#     defaultFoldFn: (seq[ParserToken], T) -> T,
+#   ],
+#   until:
+# ): BuilderResult[T] =
+
 
 # -- Stringifiers