EffectfulLaws

implicit abstract def ev: Effectful[F]

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def asyncLeftIsRaiseError[A](e: Throwable): IsEq[F[A]]

def asyncRightIsPure[A](a: A): IsEq[F[A]]

Laws from cats.effect Async[F]

def bindSuspendsEvaluation[A](fa: F[A], a1: A, f: (A, A) ⇒ A): IsEq[F[A]]

def clone(): AnyRef

def delayConstantIsPure[A](a: A): IsEq[F[A]]

Laws from cats.effect Sync[F]

def delayThrowIsRaiseError[A](e: Throwable): IsEq[F[A]]

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

def mapSuspendsEvaluation[A](fa: F[A], a1: A, f: (A, A) ⇒ A): IsEq[F[A]]

implicit def monadError: MonadError[F, Throwable]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def propagateErrorsThroughBindAsync[A](t: Throwable): IsEq[F[Either[Throwable, A]]]

def propagateErrorsThroughBindSuspend[A](t: Throwable): IsEq[F[A]]

def repeatedAsyncEvaluationNotMemoized[A](a: A, f: (A) ⇒ A): IsEq[F[A]]

def repeatedCallbackIgnored[A](a: A, f: (A) ⇒ A): IsEq[IO[A]]

def repeatedSyncEvaluationNotMemoized[A](a: A, f: (A) ⇒ A): IsEq[F[A]]

def runAsyncIgnoresErrorInHandler[A](e: Throwable): IsEq[IO[Unit]]

def runAsyncPureProducesRightIO[A](a: A): IsEq[IO[Either[Throwable, A]]]

Laws from cats.effect Effect[F]

def runAsyncRaiseErrorProducesLeftIO[A](e: Throwable): IsEq[IO[Either[Throwable, A]]]

def stackSafetyOnRepeatedAttempts: IsEq[F[Unit]]

def stackSafetyOnRepeatedLeftBinds: IsEq[F[Unit]]

def stackSafetyOnRepeatedMaps: IsEq[F[Int]]

def stackSafetyOnRepeatedRightBinds: IsEq[F[Unit]]

def suspendConstantIsPureJoin[A](fa: F[A]): IsEq[F[A]]

def suspendThrowIsRaiseError[A](e: Throwable): IsEq[F[A]]

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

def toString(): String

def unsequencedDelayIsNoop[A](a: A, f: (A) ⇒ A): IsEq[F[A]]

final def wait(): Unit

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

final def wait(arg0: Long): Unit