DeprecatedEqInstances

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

implicit def catsLawsEqForAndThen[A, B](implicit A: Arbitrary[A], B: Eq[B]): Eq[AndThen[A, B]]

Eq[AndThen] instance, built by piggybacking on catsLawsEqForFn1.

implicit def catsLawsEqForBand[A](implicit arbAA: Arbitrary[(A, A)], eqSA: Eq[kernel.Semigroup[A]], eqA: Eq[A]): Eq[Band[A]]

implicit def catsLawsEqForCommutativeSemigroup[A](implicit arbAA: Arbitrary[(A, A)], eqA: Eq[A]): Eq[CommutativeSemigroup[A]]

implicit def catsLawsEqForEq[A](implicit arbA: Arbitrary[(A, A)]): Eq[Eq[A]]

implicit def catsLawsEqForEquiv[A](implicit arbA: Arbitrary[(A, A)]): Eq[Equiv[A]]

implicit def catsLawsEqForFn2[A, B, C](implicit A: Arbitrary[A], B: Arbitrary[B], C: Eq[C]): Eq[(A, B) ⇒ C]

Create an approximation of Eq[(A, B) => C] by generating random values for A and B and comparing the application of the two functions.

implicit def catsLawsEqForGroup[A](implicit arbAA: Arbitrary[(A, A)], eqMA: Eq[kernel.Monoid[A]], eqA: Eq[A]): Eq[kernel.Group[A]]

implicit def catsLawsEqForHash[A](implicit arbA: Arbitrary[A]): Eq[kernel.Hash[A]]

Creates an approximation of Eq[Hash[A]] by generating 100 values for A and comparing the application of the two hash functions.

implicit def catsLawsEqForOrder[A](implicit arbA: Arbitrary[(A, A)]): Eq[kernel.Order[A]]

implicit def catsLawsEqForOrdering[A](implicit arbA: Arbitrary[(A, A)]): Eq[Ordering[A]]

implicit def catsLawsEqForPartialOrder[A](implicit arbA: Arbitrary[(A, A)], optIntEq: Eq[Option[Int]]): Eq[kernel.PartialOrder[A]]

implicit def catsLawsEqForPartialOrdering[A](implicit arbA: Arbitrary[(A, A)], optIntEq: Eq[Option[Int]]): Eq[PartialOrdering[A]]

implicit def catsLawsEqForSemigroup[A](implicit arbAA: Arbitrary[(A, A)], eqA: Eq[A]): Eq[kernel.Semigroup[A]]

Create an approximation of Eq[Semigroup[A]] by generating values for A and comparing the application of the two combine functions.

implicit def catsLawsEqForShow[A](implicit arg0: Arbitrary[A]): Eq[Show[A]]

Create an approximation of Eq[Show[A]] by using catsLawsEqForFn1[A, String]

def clone(): AnyRef

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def sampledEq[A, B, C](samples: Int)(f: (A, B) ⇒ C)(implicit arg0: Arbitrary[B], arg1: Eq[C]): Eq[A]

Create an approximate Eq instance for some type A, by comparing the behavior of f(x, b) and f(y, b) across many b samples.

final def synchronized[T0](arg0: ⇒ T0): T0

def toString(): String

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

implicit def catsLawsEqForFn1[A, B](implicit A: Arbitrary[A], B: Eq[B]): Eq[(A) ⇒ B]

Create an approximation of Eq[A => B] by generating random values for A and comparing the application of the two functions.