move splitWhen to list

Author: TheBugYouCantFix

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

@@ -960,49 +960,6 @@ 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,14 +304,6 @@ 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)] =

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

@@ -139,6 +139,53 @@ final class ListOps[A](private val la: List[A]) extends AnyVal {
    */
   def scanRightNel[B](b: B)(f: (A, B) => B): NonEmptyList[B] =
     NonEmptyList.fromListUnsafe(la.scanRight(b)(f))
+
+  /**
+   * Split this List into a NonEmptyList of Lists based on a predicate.
+   * The behaviour is aimed to be identical to that of haskell's `splitWhen`
+   * 
+   * {{{
+   * scala> import cats.syntax.all._
+   * scala> List(1, 1).splitWhen(_ == 1)
+   * val res0: cats.data.NonEmptyList[List[Int]] = NonEmptyList(List(), List(), List())
+   * 
+   * scala> List.empty[Int].splitWhen(_ == 1)
+   * val res1: cats.data.NonEmptyList[List[Int]] = NonEmptyList(List())
+   * 
+   * scala> List(1, 2, 3, 1, 4, 5).splitWhen(_ == 1)
+   * val res2: cats.data.NonEmptyList[List[Int]] = NonEmptyList(List(), List(2, 3), List(4, 5))
+   * }}}
+   */
+
+  def splitWhen(f: A => Boolean): NonEmptyList[List[A]] = {
+    la.reverse.foldLeft(NonEmptyList.one(List.empty[A])) { case (lst, e) =>
+      if (f(e)) Nil :: lst else NonEmptyList(e :: lst.head, lst.tail)
+    }
+  }
+
+  /**
+   * Split this List into a NonEmptyList of Lists based on the effectufl predicate. Monadic version of `splitWhen`
+   * 
+   * {{{
+   * scala> import cats.syntax.all._, cats.Eval
+   * scala> List(1, 1).splitWhenM(x => Eval.now(x == 1)).value
+   * val res0: cats.data.NonEmptyList[List[Int]] = NonEmptyList(List(), List(), List())
+   * 
+   * scala> List.empty[Int].splitWhenM(x => Eval.now(x == 1)).value
+   * val res1: cats.data.NonEmptyList[List[Int]] = NonEmptyList(List())
+   * 
+   * scala> List(1, 2, 3, 1, 4, 5).splitWhenM(x => Eval.now(x == 1)).value
+   * val res2: cats.data.NonEmptyList[List[Int]] = NonEmptyList(List(), List(2, 3), List(4, 5))
+   * }}}
+   */
+
+  def splitWhenM[G[_]](f: A => G[Boolean])(implicit M: Monad[G]): G[NonEmptyList[List[A]]] = {
+    la.reverse.foldLeft(M.pure(NonEmptyList.one(List.empty[A]))) { case (acc, e) =>
+      M.flatMap(acc) { case lst =>
+        M.map(f(e))(if (_) Nil :: lst else NonEmptyList(e :: lst.head, lst.tail))
+      }
+    }
+  }
 }
 
 private[syntax] trait ListSyntaxBinCompat0 {

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

@@ -333,29 +333,6 @@ 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

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

@@ -137,6 +137,29 @@ class ListSuite extends CatsSuite {
 
     assert(sumAll == lst.sum)
   }
+
+  test(s"splitWhen") {
+    forAll { (li: List[Int]) =>
+      val pred = (x: Int) => x > 0
+      val res = li.splitWhen(pred)
+      val expectedFiltered = li.filterNot(pred)
+      val expectedSize = li.size - expectedFiltered.size + 1
+      assert(res.size === expectedSize)
+      assert(res.toList.flatten === expectedFiltered)
+    }
+  }
+
+  test(s"splitWhenM") {
+    forAll { (li: List[Int]) =>
+      val pred = (x: Int) => x > 0
+      val predM = (x: Int) => Eval.now(pred(x))
+      val res = li.splitWhenM(predM)
+      val expectedFiltered = li.filterNot(pred)
+      val expectedSize = li.size - expectedFiltered.size + 1
+      assert(res.value.size === expectedSize)
+      assert(res.value.toList.flatten === expectedFiltered)
+    }
+  }
 }
 
 final class ListInstancesSuite extends munit.FunSuite {