added more precise syntax error handling for parsing the markdown

Author: HarrySu123

conversion2025/out.json

@@ -20,6 +20,7 @@ object Main extends IOApp {
   val host: Host = Host.fromString("localhost").getOrElse(Host.fromString("0.0.0.0").get)
   val port: Port = Port.fromInt(8080).getOrElse(Port.fromInt(80).get)
 
+  // runs the server
   def run(args: List[String]): IO[ExitCode] =
     EmberServerBuilder
       .default[IO]

conversion2025/out2.json

@@ -3,17 +3,23 @@ import parsley.token.{Lexer, Basic}
 import parsley.token.descriptions.*
 import parsley.errors.combinator.*
 
-
+// Define the lexer with a custom lexical description
 object lexer {
+
+    // Define the set of generic keywords
     private val genericKeywords = Set(
         "$$", "$"
     )
 
+    // Define the lexical description
     private val desc = LexicalDesc.plain.copy(
+        // Define how identifiers and symbols are recognized
         nameDesc = NameDesc.plain.copy(
             identifierStart = Basic(x => x.isInstanceOf[Char] && x != '$'),
             identifierLetter = Basic(x => x.isInstanceOf[Char] && x != '$'),
         ),
+
+        // Define how symbols are recognized
         symbolDesc = SymbolDesc.plain.copy(
             hardOperators = genericKeywords
         )
@@ -23,7 +29,9 @@ object lexer {
 
     def fully[A](p: Parsley[A]): Parsley[A] = lexer.fully(p)
 
+    // Define the text parser that recognizes regular text
     val text: Parsley[String] = lexer.lexeme.names.identifier
 
+    // Define the symbol parser that recognizes symbols
     val implicits = lexer.lexeme.symbol.implicits
 }

conversion2025/pandoc_testing.txt

@@ -20,11 +20,15 @@ object parser {
 
   private lazy val blocks = many(block)
 
+  // Define the block parser that recognizes different types of blocks
   private lazy val block: Parsley[Block] = 
-    atomic(Display(display)) |
-    atomic(Inline(inline)) |
+    Display(display) |
+    Inline(inline) |
     Text(lexer.text)
 
-  private lazy val display = "$$" ~> lexer.text <~ "$$"
-  private lazy val inline = "$" ~> lexer.text <~ "$"
+  // Define the display math parser that recognizes display math blocks
+  private lazy val display = "$$".label("Opening display math delimiter") ~> lexer.text <~ "$$".label("Closing display math delimiter")
+
+  // Define the inline math parser that recognizes inline math blocks
+  private lazy val inline = "$".label("Opening inline math delimiter") ~> lexer.text <~ "$".label("Closing inline math delimiter")
 }

conversion2025/pandoc_testingv2.txt

@@ -0,0 +1,24 @@
+import Block.*
+
+// check that the inline math does not contain newlines
+def inline_check(math: String): Boolean = !math.contains('\n')
+
+// validate the markdown content
+def validate_markdown(markdown: MarkDown): Boolean = {
+    markdown.content.forall {
+        case Inline(m) => inline_check(m)
+        case _         => true
+    }
+}
+
+private val INLINE_DELIM = "$"
+private val DISPLAY_DELIM = "\n$$\n"
+
+// Rebuild the markdown content from the parsed structure
+def rebuild_markdown(markdown: MarkDown): String = {
+    markdown.content.map {
+        case Text(s) => s
+        case Inline(m) => s"${INLINE_DELIM}${m}${INLINE_DELIM}"
+        case Display(m) => s"${DISPLAY_DELIM}${m.trim}${DISPLAY_DELIM}"
+    }.mkString
+}

conversion2025/tools/validator/src/main/scala/Main.scala

@@ -1,12 +1,13 @@
 import parsley.generic
 
+// This file defines the lexer for parsing mathematical expressions in Markdown format.
 case class MarkDown(content: List[Block])
 object MarkDown extends generic.ParserBridge1[List[Block],MarkDown]
 
 enum Block {
-    case Text(s: String)    // Regular text block
-    case Inline(m: String)  // Inline Math block
-    case Display(m: String) // Display Math block
+    case Text(content: String)    // Regular text block
+    case Inline(content: String)  // Inline Math block
+    case Display(content: String) // Display Math block
 }
 
 object Block {