Kleisli

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def ask[F[_], A](implicit F: Applicative[F]): Kleisli[F, A, A]

implicit def catsDataAlternativeForKleisli[F[_], A](implicit F0: Alternative[F]): Alternative[[γ$40$]Kleisli[F, A, γ$40$]]

implicit def catsDataApplicativeErrorForKleisli[F[_], E, A](implicit F0: ApplicativeError[F, E]): ApplicativeError[[γ$52$]Kleisli[F, A, γ$52$], E]

implicit def catsDataApplicativeForKleisli[F[_], A](implicit A: Applicative[F]): Applicative[[γ$55$]Kleisli[F, A, γ$55$]]

implicit def catsDataApplyForKleisli[F[_], A](implicit A: Apply[F]): Apply[[γ$56$]Kleisli[F, A, γ$56$]]

implicit def catsDataArrowChoiceForKleisli[F[_]](implicit M: Monad[F]): ArrowChoice[[β$9$, γ$10$]Kleisli[F, β$9$, γ$10$]]

implicit def catsDataChoiceForKleisli[F[_]](implicit M: Monad[F]): Choice[[β$43$, γ$44$]Kleisli[F, β$43$, γ$44$]]

implicit val catsDataChoiceForKleisliId: Choice[[β$45$, γ$46$]Kleisli[[A]A, β$45$, γ$46$]]

implicit def catsDataCommutativeArrowForKleisli[F[_]](implicit M: CommutativeMonad[F]): CommutativeArrow[[β$16$, γ$17$]Kleisli[F, β$16$, γ$17$]] with ArrowChoice[[β$18$, γ$19$]Kleisli[F, β$18$, γ$19$]]

implicit val catsDataCommutativeArrowForKleisliId: CommutativeArrow[[β$20$, γ$21$]Kleisli[[A]A, β$20$, γ$21$]]

implicit def catsDataCommutativeFlatMapForKleisli[F[_], A](implicit F0: CommutativeFlatMap[F]): CommutativeFlatMap[[γ$53$]Kleisli[F, A, γ$53$]]

implicit def catsDataCommutativeMonadForKleisli[F[_], A](implicit F0: CommutativeMonad[F]): CommutativeMonad[[γ$7$]Kleisli[F, A, γ$7$]]

implicit def catsDataComposeForKleisli[F[_]](implicit FM: FlatMap[F]): Compose[[β$47$, γ$48$]Kleisli[F, β$47$, γ$48$]]

implicit def catsDataContravariantForKleisli[F[_], C]: Contravariant[[β$38$]Kleisli[F, β$38$, C]]

implicit def catsDataContravariantMonoidalForKleisli[F[_], A](implicit F0: ContravariantMonoidal[F]): ContravariantMonoidal[[γ$14$]Kleisli[F, A, γ$14$]]

implicit def catsDataDistributiveForKleisli[F[_], R](implicit F0: Distributive[F]): Distributive[[γ$57$]Kleisli[F, R, γ$57$]]

implicit def catsDataFlatMapForKleisli[F[_], A](implicit FM: FlatMap[F]): FlatMap[[γ$42$]Kleisli[F, A, γ$42$]]

implicit def catsDataFunctorForKleisli[F[_], A](implicit F0: Functor[F]): Functor[[γ$58$]Kleisli[F, A, γ$58$]]

implicit def catsDataMonadErrorForKleisli[F[_], A, E](implicit ME: MonadError[F, E]): MonadError[[γ$11$]Kleisli[F, A, γ$11$], E]

implicit def catsDataMonadForKleisli[F[_], A](implicit M: Monad[F]): Monad[[γ$15$]Kleisli[F, A, γ$15$]]

implicit def catsDataMonadForKleisliId[A]: CommutativeMonad[[γ$12$]Kleisli[[A]A, A, γ$12$]]

implicit def catsDataMonoidForKleisli[F[_], A, B](implicit FB0: Monoid[F[B]]): Monoid[Kleisli[F, A, B]]

implicit def catsDataMonoidKForKleisli[F[_], A](implicit F0: MonoidK[F]): MonoidK[[γ$41$]Kleisli[F, A, γ$41$]]

implicit def catsDataParallelForKleisli[F[_], M[_], A](implicit P: Parallel[M, F]): Parallel[[γ$22$]Kleisli[M, A, γ$22$], [γ$23$]Kleisli[F, A, γ$23$]]

implicit def catsDataSemigroupForKleisli[F[_], A, B](implicit FB0: Semigroup[F[B]]): Semigroup[Kleisli[F, A, B]]

implicit def catsDataSemigroupKForKleisli[F[_], A](implicit F0: SemigroupK[F]): SemigroupK[[γ$51$]Kleisli[F, A, γ$51$]]

implicit def catsDataStrongForKleisli[F[_]](implicit F0: Functor[F]): Strong[[β$49$, γ$50$]Kleisli[F, β$49$, γ$50$]]

def clone(): AnyRef

def endoMonoidK[F[_]](implicit M: Monad[F]): MonoidK[[α]Kleisli[F, α, α]]

def endoSemigroupK[F[_]](implicit FM: FlatMap[F]): SemigroupK[[α]Kleisli[F, α, α]]

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 liftF[F[_], A, B](x: F[B]): Kleisli[F, A, B]

def liftK[F[_], A]: ~>[F, [γ$0$]Kleisli[F, A, γ$0$]]

Same as liftF, but expressed as a FunctionK for use with mapK

scala> import cats._, data._, implicits._
scala> val a: OptionT[Eval, Int] = 1.pure[OptionT[Eval, ?]]
scala> val b: OptionT[Kleisli[Eval, String, ?], Int] = a.mapK(Kleisli.liftK)
scala> b.value.run("").value
res0: Option[Int] = Some(1)

def local[M[_], A, R](f: (R) ⇒ R)(fa: Kleisli[M, R, A]): Kleisli[M, R, A]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def pure[F[_], A, B](x: B)(implicit F: Applicative[F]): Kleisli[F, A, B]

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

def lift[F[_], A, B](x: F[B]): Kleisli[F, A, B]