Minor Tweaks

Author: Dash-Lambda

README.md

@@ -160,12 +160,13 @@ The parent class additionally implements methods to iterate through matches and
 * `*`: Returns a parser that parses the entire input (basically making parseAllValues the result)
 * `+`: Like `*` except it fails if there are no matches
 
-There are currently 5 primary parser classes:
+There are currently 6 primary parser classes:
 * ChunkParser: Takes a function which returns an `Option`
 * PartialParser: Similar to a ChunkParser except it takes a PartialFunction
 * RecurParser: This one is for parsing to tree structures, currently used in Unlambda. It takes a `recur` function that decides when to go down a level, a `collect` function to turn a set of leaves into a node, and another parser for the non-branching tokens.
 * RegexParser: This takes a regex and a function to turn a match into the output. This one lets me condense a lot of parsers into a single line, which makes me giddy.
 * ArbitraryRecurParser: This one's called "arbitrary" because the depth isn't constant. It's given a function that can either parse the next token or tell it to go up or down a level.
+* ElementwiseParser: This one parses a sequence element by element
 
 ### How the Interface Works
 It's always a challenge to handle UI functionally. Everything behind the scenes is fair game, but actually receiving input from and sending output to the user is by definition a side-effect.

src/main/scala/grass/Grass.scala

@@ -10,17 +10,25 @@ object Grass extends Interpreter{
   val name: String = "Grass"
 
   val grassParser: EsoParser[String, Vector[Expr]] = {
-    val absReg = raw"""(w*)([Ww]*)""".r
     @tailrec
     def absArity(n: Int, p: Vector[Expr]): Vector[Expr] = {
       if(n > 0) absArity(n - 1, Vector(AbsExpr(p)))
       else p}
-    val appParser = RegexParser(raw"""(W+)(w+)""")(m => AppExpr(m.group(1).length, m.group(2).length))
-    RegexParser(raw"""([Ww]+)"""){m =>
-      m.group(1) match{
-        case absReg(arw, apps) => absArity(arw.length, appParser.parseAllValues(apps))}}}
-  
-  def apply(config: Config)(progRaw: String): Try[Seq[Char] => LazyList[Char]] = Try{eval(parse(progRaw))}
+    val appParser = RegexParser(raw"""(W+)(w+)""")(m => AppExpr(m.group(1).length, m.group(2).length)).*
+    RegexParser(raw"""(w*)([Ww]*)""")(m => absArity(m.group(1).length, appParser.parseOne(m.group(2)))).*
+      .map{res =>
+        res.flatten match{
+          case as :+ (a: AbsExpr) => as :+ a :+ AppExpr(1, 1)
+          case as => as}}
+      .withConditioning{str =>
+        filterChars(str
+          .replaceAllLiterally("\uff37", "W")
+          .replaceAllLiterally("\uff57", "w")
+          .replaceAllLiterally("\uFF56", "v")
+          .replaceAllLiterally("\uFF36", "v"),
+          "vwW").dropWhile(_ != 'w')}}
+  
+  def apply(config: Config)(progRaw: String): Try[Seq[Char] => LazyList[Char]] = Try{eval(grassParser.parseOne(progRaw))}
 
   def eval(prog: Vector[Expr]): Seq[Char] => LazyList[Char] = {
     @tailrec
@@ -30,19 +38,6 @@ object Grass extends Interpreter{
       case _ => edo(state.run())}
     inputs => LazyList.unfold(RunState(prog, Env(Vector(Out, Succ, CharFun('w'), In)), inputs, HaltState): State)(edo)}
 
-  def parse(progRaw: String): Vector[Expr] = {
-    val conditioned = filterChars(progRaw
-      .replaceAllLiterally("\uff37", "W")
-      .replaceAllLiterally("\uff57", "w")
-      .replaceAllLiterally("\uFF56", "v")
-      .replaceAllLiterally("\uFF36", "v"),
-      "vwW")
-      .dropWhile(_ != 'w')
-    
-    grassParser.parseAllValues(conditioned).flatten match{
-      case as :+ (a: AbsExpr) => as :+ a :+ AppExpr(1, 1)
-      case as => as}}
-  
   case class Env(stk: Vector[Func]){
     def apply(i: Int): Func = stk(i)
     def head: Func = stk.head

src/main/scala/parsers/AfterParser.scala

@@ -0,0 +1,5 @@
+package parsers
+
+case class AfterParser[A, B](parser: EsoParser[A, B]) extends EsoParser[A, A]{
+  def apply(inp: A): EsoParseRes[A, A] = parser(inp) mapAll {case (_, rem, s, e) => (rem, rem, s, e)}
+}

src/main/scala/parsers/ConditionalParser.scala

@@ -0,0 +1,8 @@
+package parsers
+
+case class ConditionalParser[A, B](parser: EsoParser[A, B], cond: B => Boolean) extends EsoParser[A, B]{
+  def apply(inp: A): EsoParseRes[A, B] = {
+    val res = parser(inp)
+    if(res.passed && cond(res.get)) res
+    else EsoParseFail}
+}

src/main/scala/parsers/EsoParser.scala

@@ -86,7 +86,9 @@ abstract class EsoParser[A, B] extends (A => EsoParseRes[A, B]) with EsoObj{
 
   def map[C](f: B => C): EsoParser[A, C] = MappedParser(this, f)
   def withConditioning(f: A => A): EsoParser[A, B] = ConditioningParser(this, f)
+  def onlyIf(cond: B => Boolean): ConditionalParser[A, B] = ConditionalParser(this, cond)
   def withErrors: ErrorParser[A, B] = ErrorParser(this)
+  def after: AfterParser[A, B] = AfterParser(this)
 
   def >>[C](q: EsoParser[B, C]): EsoParser[A, C] = ChainedParser(this, q)
 

src/main/scala/thue/Thue.scala

@@ -1,19 +1,21 @@
 package thue
 
-import common.{Config, EsoExcep, Interpreter}
+import common.{Config, Interpreter}
 import parsers.{EsoParser, RegexParser}
 
 import scala.annotation.tailrec
-import scala.util.matching.Regex
-import scala.util.{Failure, Success, Try}
+import scala.util.Try
 
 object Thue extends Interpreter{
   val name: String = "Thue"
 
-  val initReg: Regex = raw"""(?s)(.*)\n\s*::=\s*\n(.*)\z""".r
-  val ruleParser: EsoParser[String, (String, String)] = RegexParser(raw"""(?m)^(.*)::=(.*)$$""".r){ m => (m.group(1), m.group(2))}
+  val thueParser: EsoParser[String, (Vector[(String, String)], String)] = {
+    val spcReg = """\s*""".r
+    val pairParser = RegexParser("""(?m)^(.*)::=(.*)$$""")(m => (m.group(1), m.group(2)))
+    val ruleParser = pairParser.onlyIf{case (a, b) => !spcReg.matches(a ++ b)}
+    ruleParser.* <&> pairParser.after}
 
-  def apply(config: Config)(progRaw: String): Try[Seq[Char] => LazyList[Char]] = parse(progRaw) map{case (init, prog) => thi(init, prog, config.rands)}
+  def apply(config: Config)(progRaw: String): Try[Seq[Char] => LazyList[Char]] = thueParser(progRaw).toTry() map{case (prog, init) => thi(init, prog, config.rands)}
 
   def thi(init: String, prog: Vector[(String, String)], initRands: LazyList[Int]): Seq[Char] => LazyList[Char] = {
     def collapse(inp: Seq[Char]): Seq[String] = LazyList.unfold(inp){lst =>
@@ -35,9 +37,4 @@ object Thue extends Interpreter{
               if(v.startsWith("~")) Some((v.tail, (ac.replaceAllLiterally(k, ""), inp, rs)))
               else tdo(ac.replaceAllLiterally(k, v), inp, rs)}}}
     inputs => LazyList.unfold((init, collapse(inputs), initRands)){case (ac, inp, rs) => tdo(ac, inp, rs)}.flatten}
-  
-  def parse(progRaw: String): Try[(String, Vector[(String, String)])] = {
-    progRaw match{
-      case initReg(rls, init) => Success((init, ruleParser.parseAllValues(rls)))
-      case _ => Failure(EsoExcep("Malformed Program"))}}
 }

src/main/scala/ui/EsoCommandParser.scala

@@ -9,7 +9,7 @@ object EsoCommandParser extends EsoObj{
   val cmdParser: EsoParser[String, (String, immutable.HashMap[String, String])] = {
     val opParser = RegexParser(raw"""^(\S+)\s*""")(m => m.group(1))
     val argParser = RegexParser(raw"""[^-]*-(\S*) (\S*)""")(m => (m.group(1), m.group(2)))
-    opParser <&> argParser.*.map(mkMap(_))}
+    opParser <&> (argParser.* map (mkMap(_)))}
 
   def apply(str: String): Option[(String, immutable.HashMap[String, String])] = cmdParser(str).toOption
 }

src/main/scala/volatile/Volatile.scala

@@ -1,7 +1,7 @@
 package volatile
 
 import common.{Config, Interpreter}
-import parsers.{EsoParser, PartialParser}
+import parsers.{EsoParser, PartialElementwiseParser, PartialParser}
 import spire.math.SafeLong
 
 import scala.annotation.tailrec
@@ -10,20 +10,17 @@ import scala.util.{Success, Try}
 object Volatile extends Interpreter{
   val name: String = "Volatile"
 
-  val volParser: EsoParser[Vector[Char], VOP] = {
-    PartialParser.simple{
-      case c +: cs =>
-        val op = c match{
-          case '~' => PUSH
-          case '+' => ADD
-          case '-' => SUBT
-          case '*' => MULT
-          case '/' => DIV
-          case ':' => DUP
-          case '.' => OUT
-          case '(' => LSTART(-1)
-          case ')' => LEND(-1)}
-        (op, cs)}}
+  val volParser: EsoParser[Seq[Char], VOP] = {
+    PartialElementwiseParser[Char, VOP]{
+      case '~' => PUSH
+      case '+' => ADD
+      case '-' => SUBT
+      case '*' => MULT
+      case '/' => DIV
+      case ':' => DUP
+      case '.' => OUT
+      case '(' => LSTART(-1)
+      case ')' => LEND(-1)}}
 
   def apply(config: Config)(progRaw: String): Try[Seq[Char] => LazyList[Char]] = {
     val prog = parse(progRaw)

src/main/scala/wordlang/WordLang.scala

@@ -33,7 +33,14 @@ object WordLang extends Interpreter{
 
     val baseParser = ibvParser <+> ivbParser <+> lblParser <+> jmpParser <+> charParser
     val parParser = RegexParser[WOP](raw"""\(([^\(\)]*)\)""")(m => PrintNum(baseParser.parseAllValues(m.group(1))))
-    baseParser <+> parParser}
+    (baseParser <+> parParser)
+      .withConditioning{str =>
+        val escaped = escapeReg
+          .replaceAllIn(str, m => (-m.group(1).head).toChar.toString)
+        commentReg
+          .replaceAllIn(escaped, "")
+          .linesIterator
+          .mkString(" ")}}
 
   def apply(config: Config)(progRaw: String): Try[Seq[Char] => LazyList[Char]] = Try{parse(progRaw)} map{
     case (prog, jumps) =>
@@ -68,20 +75,13 @@ object WordLang extends Interpreter{
         case (cur, heap, mode, src, inp) => rdo(cur, heap, mode, src, inp)}.flatten}
 
   def parse(progRaw: String): (Vector[WOP], immutable.HashMap[String, Int]) = {
-    val escaped = escapeReg
-      .replaceAllIn(progRaw, m => (-m.group(1).head).toChar.toString)
-    val uncommented = commentReg
-      .replaceAllIn(escaped, "")
-      .linesIterator
-      .mkString(" ")
-    
     @tailrec
     def pdo(src: Seq[WOP], ac: Vector[WOP], acm: immutable.HashMap[String, Int]): (Vector[WOP], immutable.HashMap[String, Int]) = src match{
       case op +: ops => op match{
         case JumpLabel(nam) => pdo(ops, ac, acm + ((nam, ac.size)))
         case _ => pdo(ops, ac :+ op, acm)}
       case _ => (ac, acm)}
-    pdo(wordLangParser.parseAllValuesLazy(uncommented), Vector(), immutable.HashMap())}
+    pdo(wordLangParser.parseAllValuesLazy(progRaw), Vector(), immutable.HashMap())}
 
   trait WOP
   case class CharOp(c: Char) extends WOP