Return stack-safe Function0 and Function1 from Semigroup#combine

kernel/src/main/scala/cats/kernel/instances/FunctionInstances.scala

@@ -1,6 +1,10 @@
 package cats.kernel
 package instances
 
+import cats.kernel.compat.scalaVersionSpecific._
+import scala.util.control.TailCalls.{done, tailcall, TailRec}
+
+@suppressUnusedImportWarningForScalaVersionSpecific
 trait FunctionInstances extends FunctionInstances0 {
 
   implicit def catsKernelOrderForFunction0[A](implicit ev: Order[A]): Order[() => A] =
@@ -106,11 +110,33 @@ private[instances] trait FunctionInstances4 {
     new Function1Semigroup[A, B] { def B: Semigroup[B] = S }
 }
 
+final private[instances] case class CombineFunction1[A, B](left: A => B, right: A => B, semiB: Semigroup[B])
+    extends (A => B) {
+  private def call(fn: A => B, a: A): TailRec[B] =
+    fn match {
+      case ref: CombineFunction1[A, B] @unchecked =>
+        for {
+          lb <- tailcall(call(ref.left, a))
+          rb <- tailcall(call(ref.right, a))
+        } yield ref.semiB.combine(lb, rb)
+      case _ => done(fn(a))
+    }
+
+  final override def apply(a: A): B = call(this, a).result
+}
+
 trait Function1Semigroup[A, B] extends Semigroup[A => B] {
   implicit def B: Semigroup[B]
 
   override def combine(x: A => B, y: A => B): A => B =
-    (a: A) => B.combine(x(a), y(a))
+    CombineFunction1(x, y, B)
+
+  override def combineAllOption(fns: IterableOnce[A => B]): Option[A => B] =
+    if (fns.iterator.isEmpty) None
+    else
+      Some { (a: A) =>
+        B.combineAllOption(fns.iterator.map(_.apply(a))).get
+      }
 }
 
 trait Function1Monoid[A, B] extends Function1Semigroup[A, B] with Monoid[A => B] {
@@ -127,11 +153,33 @@ trait Function1Group[A, B] extends Function1Monoid[A, B] with Group[A => B] {
     (a: A) => B.inverse(x(a))
 }
 
+final private[instances] case class CombineFunction0[A](left: () => A, right: () => A, semiA: Semigroup[A])
+    extends (() => A) {
+  private def call(fn: () => A): TailRec[A] =
+    fn match {
+      case ref: CombineFunction0[A] @unchecked =>
+        for {
+          la <- tailcall(call(ref.left))
+          ra <- tailcall(call(ref.right))
+        } yield ref.semiA.combine(la, ra)
+      case _ => done(fn())
+    }
+
+  final override def apply(): A = call(this).result
+}
+
 trait Function0Semigroup[A] extends Semigroup[() => A] {
   implicit def A: Semigroup[A]
 
   override def combine(x: () => A, y: () => A): () => A =
-    () => A.combine(x(), y())
+    CombineFunction0(x, y, A)
+
+  override def combineAllOption(fns: IterableOnce[() => A]): Option[() => A] =
+    if (fns.iterator.isEmpty) None
+    else
+      Some { () =>
+        A.combineAllOption(fns.iterator.map(_.apply())).get
+      }
 }
 
 trait Function0Monoid[A] extends Function0Semigroup[A] with Monoid[() => A] {

tests/src/test/scala/cats/tests/FunctionSuite.scala

@@ -183,4 +183,18 @@ class FunctionSuite extends CatsSuite {
     val sumAll = bigList.combineAll(MonoidK[Endo].algebra)
     List(1, 1, 1).map(sumAll)
   }
+
+  property("Semigroup[Function0[Semi]] is stack safe on combine") {
+    forAll { (f: Function0[Semi]) =>
+      1.to(50000).foldLeft(f)((acc, _) => Semigroup[Function0[Semi]].combine(acc, f)).apply()
+      true
+    }
+  }
+
+  property("Semigroup[Function1[MiniInt, Semi]] is stack safe on combine") {
+    forAll { (i: MiniInt, f: Function1[MiniInt, Semi]) =>
+      1.to(50000).foldLeft(f)((acc, _) => Semigroup[Function1[MiniInt, Semi]].combine(acc, f)).apply(i)
+      true
+    }
+  }
 }