remove casts from Eval, fix stack overflow in Eval

core/src/main/scala/cats/Eval.scala

@@ -263,26 +263,13 @@ object Eval extends EvalInstances {
    * of FlatMap nodes) or "value" (in the case of Now, Later, or
    * Always nodes).
    */
-  @tailrec private def advance[A](fa: Eval[A]): Eval[A] =
-    fa match {
+  @tailrec private def advance[A](fa: Defer[A]): Eval[A] =
+    fa.thunk() match {
       case call: Eval.Defer[A] =>
-        advance(call.thunk())
-      case compute: Eval.FlatMap[A] =>
-        new Eval.FlatMap[A] {
-          type Start = compute.Start
-          val start: () => Eval[Start] = () => compute.start()
-          val run: Start => Eval[A] = s => advance1(compute.run(s))
-        }
+        advance(call)
       case other => other
     }
 
-  /**
-   * Alias for advance that can be called in a non-tail position
-   * from an otherwise tailrec-optimized advance.
-   */
-  private def advance1[A](fa: Eval[A]): Eval[A] =
-    advance(fa)
-
   /**
    * FlatMap is a type of Eval[A] that is used to chain computations
    * involving .map and .flatMap. Along with Eval#flatMap it
@@ -318,52 +305,70 @@ object Eval extends EvalInstances {
       }
   }
 
-  private def evaluate[A](e: Eval[A]): A = {
-    type L = Eval[Any]
-    type M = Memoize[Any]
-    type C = Any => Eval[Any]
+  /*
+   * This represents the stack of flatmap functions in a series
+   * of Eval operations
+   */
+  sealed abstract private class FnStack[A, B]
+  final private case class Ident[A, B](ev: A <:< B) extends FnStack[A, B]
+  final private case class Many[A, B, C](first: A => Eval[B], rest: FnStack[B, C]) extends FnStack[A, C]
 
-    def addToMemo(m: M): C = { (a: Any) =>
+  private def evaluate[A](e: Eval[A]): A = {
+    def addToMemo[A1](m: Memoize[A1]): A1 => Eval[A1] = { (a: A1) =>
       m.result = Some(a)
       Now(a)
     }
 
-    @tailrec def loop(curr: L, fs: List[C]): Any =
+    @tailrec def loop[A1](curr: Eval[A1], fs: FnStack[A1, A]): A =
       curr match {
-        case c: FlatMap[_] =>
+        case c: FlatMap[A1] =>
           c.start() match {
-            case cc: FlatMap[_] =>
-              loop(cc.start().asInstanceOf[L], cc.run.asInstanceOf[C] :: c.run.asInstanceOf[C] :: fs)
+            case cc: FlatMap[c.Start] =>
+              val nextFs = Many(c.run, fs)
+              loop(cc.start(), Many(cc.run, nextFs))
+            case call: Defer[c.Start] =>
+              // though the flatMap method handles defer(x).flatMap(f)
+              // by removing the Defer, we can nest defers,
+              // so defer(defer(x)).flatMap(f) could mean c.start()
+              // returns a Defer. We have to handle it here
+              loop(advance(call), Many(c.run, fs))
             case mm @ Memoize(eval) =>
               mm.result match {
                 case Some(a) =>
-                  loop(Now(a), c.run.asInstanceOf[C] :: fs)
+                  loop(c.run(a), fs)
                 case None =>
-                  loop(eval, addToMemo(mm.asInstanceOf[M]) :: c.run.asInstanceOf[C] :: fs)
+                  val nextFs = Many(c.run, fs)
+                  loop(eval, Many(addToMemo(mm), nextFs))
               }
             case xx =>
+              // xx must be Now, Later, Always, all of those
+              // have safe .value:
               loop(c.run(xx.value), fs)
           }
-        case call: Defer[_] =>
+        case call: Defer[A1] =>
           loop(advance(call), fs)
-        case m @ Memoize(eval) =>
+        case m: Memoize[a] =>
+          // a <:< A1
           m.result match {
             case Some(a) =>
               fs match {
-                case f :: fs => loop(f(a), fs)
-                case Nil     => a
+                case Many(f, fs) => loop(f(a), fs)
+                case Ident(ev)   => ev(a)
               }
             case None =>
-              loop(eval, addToMemo(m.asInstanceOf[M]) :: fs)
+              loop[a](m.eval, Many[a, A1, A](addToMemo[a](m), fs))
           }
         case x =>
+          // Now, Later or Always don't have recursions
+          // so they have safe .value:
+          val a1 = x.value
           fs match {
-            case f :: fs => loop(f(x.value), fs)
-            case Nil     => x.value
+            case Many(f, fs) => loop(f(a1), fs)
+            case Ident(ev)   => ev(a1)
           }
       }
 
-    loop(e.asInstanceOf[L], Nil).asInstanceOf[A]
+    loop(e, Ident(implicitly[A <:< A]))
   }
 }
 

tests/src/test/scala/cats/tests/EvalSuite.scala

@@ -96,6 +96,14 @@ class EvalSuite extends CatsSuite {
     spooky.counter should ===(2)
   }
 
+  test("Defer and FlatMap compose without blowing the stack") {
+    def inc(a: Eval[Int], count: Int): Eval[Int] =
+      if (count <= 0) a
+      else Eval.defer(Eval.defer(inc(a, count - 1))).flatMap { i => Eval.now(i + 1) }
+
+    assert(inc(Eval.now(0), 1000000).value == 1000000)
+  }
+
   {
     implicit val iso: SemigroupalTests.Isomorphisms[Eval] =
       SemigroupalTests.Isomorphisms.invariant[Eval]