Move contain_ to UnorderedFoldableOps

Author: BalmungSan

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

@@ -70,21 +70,7 @@ final class FoldableOps[F[_], A](private val fa: F[A]) extends AnyVal {
   def foldA[G[_], B](implicit F: Foldable[F], ev: A <:< G[B], G: Applicative[G], B: Monoid[B]): G[B] =
     F.foldA[G, B](fa.asInstanceOf[F[G[B]]])
 
-  /**
-   * test if `F[A]` contains an `A`, named contains_ to avoid conflict with existing contains which uses universal equality
-   *
-   * Example:
-   * {{{
-   * scala> import cats.implicits._
-   *
-   * scala> val l: List[Int] = List(1, 2, 3, 4)
-   * scala> l.contains_(1)
-   * res0: Boolean = true
-   * scala> l.contains_(5)
-   * res1: Boolean = false
-   * }}}
-   */
-  def contains_(v: A)(implicit ev: Eq[A], F: Foldable[F]): Boolean =
+  private[syntax] def contains_(v: A, ev: Eq[A], F: Foldable[F]): Boolean =
     F.exists(fa)(ev.eqv(_, v))
 
   /**
@@ -185,7 +171,8 @@ final class FoldableOps[F[_], A](private val fa: F[A]) extends AnyVal {
    * res3: Either[String,Option[Int]] = Left(error)
    * }}}
    */
-  def findM[G[_]](p: A => G[Boolean])(implicit F: Foldable[F], G: Monad[G]): G[Option[A]] = F.findM[G, A](fa)(p)
+  def findM[G[_]](p: A => G[Boolean])(implicit F: Foldable[F], G: Monad[G]): G[Option[A]] =
+    F.findM[G, A](fa)(p)
 
   /**
    * Tear down a subset of this structure using a `PartialFunction`.
@@ -196,7 +183,8 @@ final class FoldableOps[F[_], A](private val fa: F[A]) extends AnyVal {
    * res0: Int = 6
    * }}}
    */
-  def collectFold[M](f: PartialFunction[A, M])(implicit F: Foldable[F], M: Monoid[M]): M = F.collectFold[A, M](fa)(f)
+  def collectFold[M](f: PartialFunction[A, M])(implicit F: Foldable[F], M: Monoid[M]): M =
+    F.collectFold[A, M](fa)(f)
 
   /**
    * Tear down a subset of this structure using a `A => Option[M]`.
@@ -209,7 +197,8 @@ final class FoldableOps[F[_], A](private val fa: F[A]) extends AnyVal {
    * }}}
    */
   @deprecated("Use collectFoldSome", "2.1.0-RC1")
-  def collectSomeFold[M](f: A => Option[M])(implicit F: Foldable[F], M: Monoid[M]): M = F.collectFoldSome[A, M](fa)(f)
+  def collectSomeFold[M](f: A => Option[M])(implicit F: Foldable[F], M: Monoid[M]): M =
+    F.collectFoldSome[A, M](fa)(f)
 }
 
 final class FoldableOps0[F[_], A](private val fa: F[A]) extends AnyVal {
@@ -246,7 +235,8 @@ final class FoldableOps0[F[_], A](private val fa: F[A]) extends AnyVal {
    * a: String = "foo321"
    * }}}
    */
-  def foldMapK[G[_], B](f: A => G[B])(implicit F: Foldable[F], G: MonoidK[G]): G[B] = F.foldMapK(fa)(f)
+  def foldMapK[G[_], B](f: A => G[B])(implicit F: Foldable[F], G: MonoidK[G]): G[B] =
+    F.foldMapK(fa)(f)
 
   /**
    * Separate this Foldable into a Tuple by an effectful separating function `A => H[B, C]` for some `Bifoldable[H]`
@@ -305,23 +295,40 @@ 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 sliding2(implicit F: Foldable[F]): List[(A, A)] = F.sliding2(fa)
-  def sliding3(implicit F: Foldable[F]): List[(A, A, A)] = F.sliding3(fa)
-  def sliding4(implicit F: Foldable[F]): List[(A, A, A, A)] = F.sliding4(fa)
-  def sliding5(implicit F: Foldable[F]): List[(A, A, A, A, A)] = F.sliding5(fa)
-  def sliding6(implicit F: Foldable[F]): List[(A, A, A, A, A, A)] = F.sliding6(fa)
-  def sliding7(implicit F: Foldable[F]): List[(A, A, A, A, A, A, A)] = F.sliding7(fa)
-  def sliding8(implicit F: Foldable[F]): List[(A, A, A, A, A, A, A, A)] = F.sliding8(fa)
-  def sliding9(implicit F: Foldable[F]): List[(A, A, A, A, A, A, A, A, A)] = F.sliding9(fa)
-  def sliding10(implicit F: Foldable[F]): List[(A, A, A, A, A, A, A, A, A, A)] = F.sliding10(fa)
-  def sliding11(implicit F: Foldable[F]): List[(A, A, A, A, A, A, A, A, A, A, A)] = F.sliding11(fa)
-  def sliding12(implicit F: Foldable[F]): List[(A, A, A, A, A, A, A, A, A, A, A, A)] = F.sliding12(fa)
-  def sliding13(implicit F: Foldable[F]): List[(A, A, A, A, A, A, A, A, A, A, A, A, A)] = F.sliding13(fa)
-  def sliding14(implicit F: Foldable[F]): List[(A, A, A, A, A, A, A, A, A, A, A, A, A, A)] = F.sliding14(fa)
-  def sliding15(implicit F: Foldable[F]): List[(A, A, A, A, A, A, A, A, A, A, A, A, A, A, A)] = F.sliding15(fa)
-  def sliding16(implicit F: Foldable[F]): List[(A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A)] = F.sliding16(fa)
-  def sliding17(implicit F: Foldable[F]): List[(A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A)] = F.sliding17(fa)
-  def sliding18(implicit F: Foldable[F]): List[(A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A)] = F.sliding18(fa)
+  def sliding2(implicit F: Foldable[F]): List[(A, A)] =
+    F.sliding2(fa)
+  def sliding3(implicit F: Foldable[F]): List[(A, A, A)] =
+    F.sliding3(fa)
+  def sliding4(implicit F: Foldable[F]): List[(A, A, A, A)] =
+    F.sliding4(fa)
+  def sliding5(implicit F: Foldable[F]): List[(A, A, A, A, A)] =
+    F.sliding5(fa)
+  def sliding6(implicit F: Foldable[F]): List[(A, A, A, A, A, A)] =
+    F.sliding6(fa)
+  def sliding7(implicit F: Foldable[F]): List[(A, A, A, A, A, A, A)] =
+    F.sliding7(fa)
+  def sliding8(implicit F: Foldable[F]): List[(A, A, A, A, A, A, A, A)] =
+    F.sliding8(fa)
+  def sliding9(implicit F: Foldable[F]): List[(A, A, A, A, A, A, A, A, A)] =
+    F.sliding9(fa)
+  def sliding10(implicit F: Foldable[F]): List[(A, A, A, A, A, A, A, A, A, A)] =
+    F.sliding10(fa)
+  def sliding11(implicit F: Foldable[F]): List[(A, A, A, A, A, A, A, A, A, A, A)] =
+    F.sliding11(fa)
+  def sliding12(implicit F: Foldable[F]): List[(A, A, A, A, A, A, A, A, A, A, A, A)] =
+    F.sliding12(fa)
+  def sliding13(implicit F: Foldable[F]): List[(A, A, A, A, A, A, A, A, A, A, A, A, A)] =
+    F.sliding13(fa)
+  def sliding14(implicit F: Foldable[F]): List[(A, A, A, A, A, A, A, A, A, A, A, A, A, A)] =
+    F.sliding14(fa)
+  def sliding15(implicit F: Foldable[F]): List[(A, A, A, A, A, A, A, A, A, A, A, A, A, A, A)] =
+    F.sliding15(fa)
+  def sliding16(implicit F: Foldable[F]): List[(A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A)] =
+    F.sliding16(fa)
+  def sliding17(implicit F: Foldable[F]): List[(A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A)] =
+    F.sliding17(fa)
+  def sliding18(implicit F: Foldable[F]): List[(A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A)] =
+    F.sliding18(fa)
   def sliding19(implicit F: Foldable[F]): List[(A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A)] =
     F.sliding19(fa)
   def sliding20(implicit F: Foldable[F]): List[(A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A)] =

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

@@ -29,6 +29,23 @@ trait UnorderedFoldableSyntax extends UnorderedFoldable.ToUnorderedFoldableOps {
 
 final class UnorderedFoldableOps[F[_], A](private val fa: F[A]) extends AnyVal {
 
+  /**
+   * test if `F[A]` contains an `A`, named contains_ to avoid conflict with existing contains which uses universal equality
+   *
+   * Example:
+   * {{{
+   * scala> import cats.implicits._
+   *
+   * scala> val l: List[Int] = List(1, 2, 3, 4)
+   * scala> l.contains_(1)
+   * res0: Boolean = true
+   * scala> l.contains_(5)
+   * res1: Boolean = false
+   * }}}
+   */
+  def contains_(v: A)(implicit ev: Eq[A], F: UnorderedFoldable[F]): Boolean =
+    F.exists(fa)(a => ev.eqv(a, v))
+
   /**
    * Count the number of elements in the structure that satisfy the given predicate.
    *