Remove concatination from the builder, it's now the duty of the internal method

src/org/org_builder.nim

@@ -8,12 +8,19 @@ type OrgBuilder* = Builder[OrgBuilderT]
 type OrgBuilderResult* = BuilderResult[OrgBuilderT]
 
 func makeOrgBuilderToken*(kind: orgElementKind): string -> OrgBuilderT =
+
+func textTokenizer*(kind: orgElementKind): seq[ParserToken] -> seq[OrgBuilderT] =
+  return func(tokens: seq[ParserToken]): seq[OrgBuilderT] =
+    return @[
+      OrgBuilderT(
+        kind: kind,
+        content: tokens.tokensToString(),
+      )
+    ]
+
+func rawTextTokenizer*(kind: orgElementKind): string -> OrgBuilderT =
   return func(content: string): OrgBuilderT =
     return OrgBuilderT(
-      kind: orgRawText,
+      kind: kind,
       content: content,
     )
-
-proc mergeOrgTokens*(tokenizer: string -> OrgBuilderT): (seq[ParserToken], seq[OrgBuilderT]) -> seq[OrgBuilderT] =
-  return proc(parserTokens: seq[ParserToken], builderTokens: seq[OrgBuilderT]): seq[OrgBuilderT] =
-    return builderTokens & tokenizer(parserTokens.tokensToString())

src/org/org_text_delimiter.nim

@@ -18,21 +18,21 @@ let verbatimParser* = parseBetweenPair(ch('='))
 let codeParser* =             parseBetweenPair(ch('~'))
 let strikeThroughParser* =    parseBetweenPair(ch('+'))
 
-let rawTokenizer* = makeOrgBuilderToken(orgRawText)
+let rawTokenizer* =           rawTextTokenizer(orgRawText)
-let boldTokenizer* = makeOrgBuilderToken(orgBoldText)
+let boldTokenizer* =          textTokenizer(orgBoldText)
-let italicTokenizer* = makeOrgBuilderToken(orgItalicText)
+let italicTokenizer* =        textTokenizer(orgItalicText)
-let underlineTokenizer* = makeOrgBuilderToken(orgUnderlineText)
+let underlineTokenizer* =     textTokenizer(orgUnderlineText)
-let verbatimTokenizer* = makeOrgBuilderToken(orgVerbatimText)
+let verbatimTokenizer* =      textTokenizer(orgVerbatimText)
-let codeTokenizer* = makeOrgBuilderToken(orgCodeText)
+let codeTokenizer* =          textTokenizer(orgCodeText)
-let strikeThroughTokenizer* = makeOrgBuilderToken(orgStrikeThroughText)
+let strikeThroughTokenizer* = textTokenizer(orgStrikeThroughText)
 
 let orgStyledTextBuilders = @[
-  (boldParser,           mergeOrgTokens(boldTokenizer)),
+  (boldParser,                boldTokenizer),
-  (italicParser,         mergeOrgTokens(italicTokenizer)),
+  (italicParser,              italicTokenizer),
-  (underlineParser,      mergeOrgTokens(underlineTokenizer)),
+  (underlineParser,           underlineTokenizer),
-  (verbatimParser,       mergeOrgTokens(verbatimTokenizer)),
+  (verbatimParser,            verbatimTokenizer),
-  (codeParser,           mergeOrgTokens(codeTokenizer)),
+  (codeParser,                codeTokenizer),
-  (strikeThroughParser,  mergeOrgTokens(strikeThroughTokenizer)),
+  (strikeThroughParser,       strikeThroughTokenizer),
 ]
 
 proc makeRawTokenOrEmpty(tokens: seq[ParserToken]): seq[OrgBuilderT] =
@@ -43,10 +43,9 @@ proc makeRawTokenOrEmpty(tokens: seq[ParserToken]): seq[OrgBuilderT] =
   else: @[rawTokenizer(str)]
 
 when isMainModule:
-  let test = OrgBuilderResult.ok(OrgBuilder((
+  let test = initOrgBuilder(
-      parser: initParser("Regular *bold* /italic/ _underline_ =verbatim= ~code~ +strikethrough+"),
+    "Regular *bold* /italic/ _underline_ =verbatim= ~code~ +strikethrough+"
-      tree: newSeq[OrgBuilderT](),
+  )
-  )))
   .flatMap((builder: OrgBuilder) => tryParseBuild(
     builder = builder,
     builderFns = orgStyledTextBuilders,

src/parser/builder_api.nim

@@ -11,9 +11,9 @@ proc tryParseBuild*[T](
   builder: Builder[T],
   builderFns: seq[tuple[
     parserFn: Parser -> ParserResult,
-    concatFn: (seq[ParserToken], seq[T]) -> seq[T],
+    builderFn: seq[ParserToken] -> seq[T],
   ]],
-  defaultBuilderFn: (seq[ParserToken]) -> seq[T],
+  defaultBuilderFn: seq[ParserToken] -> seq[T],
   stopAtParserFn = newline,
 ): BuilderResult[T] =
   ## Parse remaining text in `builder` by going checking in the `builderFns` list for a sucessful `parserFn`.
@@ -32,8 +32,8 @@ proc tryParseBuild*[T](
 
     # Find the first matching parser and convert its tokens
     var found = false
-    for builderFn in builderFns:
+    for fn in builderFns:
-      let (parserFn, concatFn) = builderFn
+      let (parserFn, builderFn) = fn
 
       let parseResult = emptyParser.flatMap(parserFn)
       if parseResult.isOk():
@@ -50,10 +50,11 @@ proc tryParseBuild*[T](
         parserAcc = parseResult.map(emptyTokens)
         builderAcc = builder.initBuilder(
           okParser,
-          concatFn(
+          concat(
-            okParser.tokens,
+            builderAcc[1],
-            builderAcc[1] & defaultBuilderTokens,
+            defaultBuilderTokens,
-          ),
+            builderFn(okParser.tokens),
+          )
         )
         break
 
@@ -68,5 +69,8 @@ proc tryParseBuild*[T](
 
   BuilderResult[T].ok(builder.initBuilder(
     builderAcc[0],
-    builderAcc[1] & defaultBuilderTokens,
+    concat(
+      builderAcc[1],
+      defaultBuilderTokens,
+    ),
   ))