refactor: switched ChainPre to use a custom AndThen, instead of dedicated stack

Author: j-mie6

parsley/shared/src/main/scala/parsley/internal/deepembedding/backend/IterativeEmbedding.scala

@@ -73,14 +73,14 @@ private [deepembedding] final class ChainPre[A](p: StrictParsley[A], op: StrictP
     override def codeGen[M[_, +_]: ContOps, R](producesResults: Boolean)(implicit instrs: InstrBuffer, state: CodeGenState): M[R, Unit] = {
         val body = state.freshLabel()
         val handler = state.freshLabel()
-        if (producesResults) instrs += new instructions.Push(instructions.PreOps.empty)
+        if (producesResults) instrs += new instructions.Push(identity[A] _)
         instrs += new instructions.PushHandler(handler)
         instrs += new instructions.Label(body)
         suspend(op.codeGen[M, R](producesResults)) >> {
             instrs += new instructions.Label(handler)
             instrs += (if (producesResults) new instructions.ChainPre(body) else new instructions.SkipMany(body))
             suspend(p.codeGen[M, R](producesResults)) |> {
-                if (producesResults) instrs += instructions.ChainPreReduce
+                if (producesResults) instrs += instructions.Apply
             }
         }
     }

parsley/shared/src/main/scala/parsley/internal/machine/instructions/IterativeInstrs.scala

@@ -71,20 +71,18 @@ private [internal] final class ChainPost(var label: Int) extends InstrWithLabel
     // $COVERAGE-ON$
 }
 
-private [internal] final class PreOps(val op: Any => Any, val rest: PreOps)
-private [internal] object PreOps {
-    val empty: PreOps = null
-    private [instructions] def reduce(ops: PreOps, x: Any): Any = {
-        if (ops eq empty) x
-        else reduce(ops.rest, ops.op(x))
-    }
+private final class AndThen[-A, B, +C](f: A => B, g: B => C) extends (A => C) {
+    final def apply(x: A): C = g match {
+        case g: AndThen[_, _, _] => g(f(x))
+        case g                   => g(f(x))
+    } 
 }
 
 private [internal] final class ChainPre(var label: Int) extends InstrWithLabel {
     override def apply(ctx: Context): Unit = {
         if (ctx.good) {
             val f = ctx.stack.pop[Any => Any]()
-            ctx.stack.exchange(new PreOps(f, ctx.stack.peek[PreOps]))
+            ctx.stack.exchange(new AndThen(f, ctx.stack.peek[Any => Any]))
             ctx.updateCheckOffset()
             ctx.pc = label
         }
@@ -99,17 +97,6 @@ private [internal] final class ChainPre(var label: Int) extends InstrWithLabel {
     override def toString: String = s"ChainPre($label)"
     // $COVERAGE-ON$
 }
-private [internal] object ChainPreReduce extends Instr {
-    override def apply(ctx: Context): Unit = {
-        ensureRegularInstruction(ctx)
-        val x = ctx.stack.upop()
-        val f = ctx.stack.peek[PreOps]
-        ctx.exchangeAndContinue(PreOps.reduce(f, x))
-    }
-    // $COVERAGE-OFF$
-    override def toString: String = s"ChainPreReduce"
-    // $COVERAGE-ON$
-}
 
 private [internal] final class Chainl(var label: Int) extends InstrWithLabel {
     override def apply(ctx: Context): Unit = {