fix foldMap stack safety

free/src/main/scala/cats/free/Free.scala

@@ -130,12 +130,17 @@ sealed abstract class Free[S[_], A] extends Product with Serializable {
    * Run to completion, mapping the suspension with the given transformation at each step and
    * accumulating into the monad `M`.
    */
-  final def foldMap[M[_]](f: S ~> M)(implicit M: Monad[M]): M[A] =
+  @tailrec
+  final def foldMap[M[_]](f: S ~> M)(implicit M: Monad[M]): M[A] = {
     step match {
       case Pure(a) => M.pure(a)
       case Suspend(s) => f(s)
-      case Gosub(c, g) => M.flatMap(c.foldMap(f))(cc => g(cc).foldMap(f))
+      case Gosub(c, g) => c match {
+        case Suspend(s) => g(f(s)).foldMap(f)
+        case _ => throw new Error("Unexpected operation. The case should have been eliminated by `step`.")
+      }
     }
+  }
 
   /**
    * Compile your Free into another language by changing the suspension functor

free/src/test/scala/cats/free/FreeTests.scala

@@ -28,4 +28,26 @@ class FreeTests extends CatsSuite {
       x.mapSuspension(NaturalTransformation.id[List]) should === (x)
     }
   }
+
+  test("foldMap is stack safe") {
+    trait FTestApi[A]
+    case class TB(i: Int) extends FTestApi[Int]
+
+    type FTest[A] = Free[FTestApi, A]
+
+    def tb(i: Int): FTest[Int] = Free.liftF(TB(i))
+
+    def a(i: Int): FTest[Int] = for {
+      j <- tb(i)
+      z <- if (j<10000) a(j) else Free.pure[FTestApi, Int](j)
+    } yield z
+
+    def runner: FTestApi ~> Id = new (FTestApi ~> Id) {
+      def apply[A](fa: FTestApi[A]): Id[A] = fa match {
+        case TB(i) => i+1
+      }
+    }
+
+    assert(10000 == a(0).foldMap(runner))
+  }
 }