splitWhen & splitWhenM for Foldable

Author: TheBugYouCantFix

core/src/main/scala/cats/Foldable.scala

@@ -960,6 +960,49 @@ trait Foldable[F[_]] extends UnorderedFoldable[F] with FoldableNFunctions[F] { s
     import cats.instances.either.*
     partitionBifoldM[G, Either, A, B, C](fa)(f)(A, M, Bifoldable[Either])
   }
+
+  /**
+   * Split this Foldable into a List of Lists based on a predicate.
+   * The behaviour is aimed to be identical to that of haskell's `splitWhen`
+   * 
+   * {{{
+   * scala> import cats.syntax.all._, cats.Foldable
+   * scala> Foldable[List].splitWhen(List(1,1))(_ == 1)
+   * res1: List[List[Int]] = List(List(), List(), List())
+   * scala> Foldable[List].splitWhen(Nil)(_ == 1)
+   * res2: List[List[Nothing]] = List(List())
+   * scala> Foldable[List].splitWhen(List(1, 2, 3, 1, 4, 5))(_ == 1)
+   * res3: List[List[Int]] = List(List(), List(2, 3), List(4, 5))
+   * }}}
+   */
+
+  def splitWhen[A](fa: F[A])(f: A => Boolean): List[List[A]] = {
+    toList(fa).reverse.foldLeft(List.empty[A] :: Nil) { case (lst, e) =>
+      if (f(e)) Nil :: lst else (e :: lst.head) :: lst.tail
+    }
+  }
+
+  /**
+   * Split this Foldable into a List of Lists based on the effectufl predicate. Monadic version of `splitWhen`
+   * 
+   * {{{
+   * scala> import cats.syntax.all._, cats.Foldable, cats.Eval
+   * scala> Foldable[List].splitWhenM(List(1,1))(x => Eval.now(x == 1)).value
+   * res1: List[List[Int]] = List(List(), List(), List())
+   * scala> Foldable[List].splitWhenM(List.empty[Int])(x => Eval.now(x == 1)).value
+   * res2: List[List[Int]] = List(List())
+   * scala> Foldable[List].splitWhenM(List(1, 2, 3, 1, 4, 5))(x => Eval.now(x == 1)).value
+   * val res3: List[List[Int]] = List(List(), List(2, 3), List(4, 5))
+   * }}}
+   */
+
+  def splitWhenM[G[_], A](fa: F[A])(f: A => G[Boolean])(implicit M: Monad[G]): G[List[List[A]]] = {
+    toList(fa).reverse.foldLeft(M.pure(List.empty[A] :: Nil)) { case (acc, e) =>
+      M.flatMap(acc) { case lst =>
+        M.map(f(e))(if (_) Nil :: lst else (e :: lst.head) :: lst.tail)
+      }
+    }
+  }
 }
 
 object Foldable {

core/src/main/scala/cats/syntax/foldable.scala

@@ -304,6 +304,14 @@ final class FoldableOps0[F[_], A](private val fa: F[A]) extends AnyVal {
   )(implicit A: Alternative[F], F: Foldable[F], M: Monad[G]): G[(F[B], F[C])] =
     F.partitionEitherM[G, A, B, C](fa)(f)(A, M)
 
+  def splitWhen(f: A => Boolean)(implicit F: Foldable[F]): List[List[A]] = {
+    F.splitWhen[A](fa)(f)
+  }
+
+  def splitWhenM[G[_]](f: A => G[Boolean])(implicit F: Foldable[F], G: Monad[G]): G[List[List[A]]] = {
+    F.splitWhenM[G, A](fa)(f)(G)
+  }
+
   def sliding2(implicit F: Foldable[F]): List[(A, A)] =
     F.sliding2(fa)
   def sliding3(implicit F: Foldable[F]): List[(A, A, A)] =

tests/shared/src/test/scala/cats/tests/FoldableSuite.scala

@@ -333,6 +333,29 @@ abstract class FoldableSuite[F[_]: Foldable](name: String)(implicit
     }
   }
 
+  test(s"Foldable[$name].splitWhen") {
+    forAll { (fa: F[Int]) =>
+      val pred = (x: Int) => x > 0
+      val res = fa.splitWhen(pred)
+      val expectedFiltered = iterator(fa).filterNot(pred).toList
+      val expectedSize = fa.size - expectedFiltered.size + 1
+      assert(res.size.toLong === expectedSize)
+      assert(res.flatten === expectedFiltered)
+    }
+  }
+
+  test(s"Foldable[$name].splitWhenM") {
+    forAll { (fa: F[Int]) =>
+      val pred = (x: Int) => x > 0
+      val predM = (x: Int) => Eval.now(pred(x))
+      val res = fa.splitWhenM(predM)
+      val expectedFiltered = iterator(fa).filterNot(pred).toList
+      val expectedSize = fa.size - expectedFiltered.size + 1
+      assert(res.value.size.toLong === expectedSize)
+      assert(res.value.flatten === expectedFiltered)
+    }
+  }
+
   test(s"Foldable[$name].sliding2 consistent with List#sliding(2)") {
     forAll { (fi: F[Int]) =>
       val n = 2