Kleisli

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def andThen[C](k: Kleisli[F, B, C])(implicit F: FlatMap[F]): Kleisli[F, A, C]

Tip to tail Kleisli arrow composition.

scala> import cats.data.Kleisli, cats.implicits._
scala> val takeHead = Kleisli[Option, List[Int], Int](_.headOption)
scala> val plusOne = Kleisli[Option, Int, Int](i => Some(i + 1))
scala> (takeHead andThen plusOne).run(List(1))
res0: Option[Int] = Some(2)

def andThen[C](f: (B) ⇒ F[C])(implicit F: FlatMap[F]): Kleisli[F, A, C]

Composes run with a function B => F[C] not lifted into Kleisli.

def ap[C](f: Kleisli[F, A, (B) ⇒ C])(implicit F: Apply[F]): Kleisli[F, A, C]

def apply(a: A): F[B]

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def compose[Z](k: Kleisli[F, Z, A])(implicit F: FlatMap[F]): Kleisli[F, Z, B]

def compose[Z](f: (Z) ⇒ F[A])(implicit F: FlatMap[F]): Kleisli[F, Z, B]

def dimap[C, D](f: (C) ⇒ A)(g: (B) ⇒ D)(implicit F: Functor[F]): Kleisli[F, C, D]

Performs local and map simultaneously.

final def eq(arg0: AnyRef): Boolean

def finalize(): Unit

def first[C](implicit F: Functor[F]): Kleisli[F, (A, C), (B, C)]

def flatMap[C](f: (B) ⇒ Kleisli[F, A, C])(implicit F: FlatMap[F]): Kleisli[F, A, C]

def flatMapF[C](f: (B) ⇒ F[C])(implicit F: FlatMap[F]): Kleisli[F, A, C]

final def getClass(): Class[_]

final def isInstanceOf[T0]: Boolean

def lift[G[_]](implicit G: Applicative[G]): Kleisli[[α]G[F[α]], A, B]

def local[AA](f: (AA) ⇒ A): Kleisli[F, AA, B]

Contramap the input using f, where f may modify the input type of the Kleisli arrow.

scala> import cats.data.Kleisli, cats.implicits._
scala> type ParseResult[A] = Either[Throwable, A]
scala> val parseInt = Kleisli[ParseResult, String, Int](s => Either.catchNonFatal(s.toInt))
scala> parseInt.local[List[String]](_.combineAll).run(List("1", "2"))
res0: ParseResult[Int] = Right(12)

def lower(implicit F: Applicative[F]): Kleisli[F, A, F[B]]

def map[C](f: (B) ⇒ C)(implicit F: Functor[F]): Kleisli[F, A, C]

Modify the output of the Kleisli function with f.

scala> import cats.data.Kleisli, cats.implicits._
scala> val takeHead = Kleisli[Option, List[Int], Int](_.headOption)
scala> takeHead.map(_.toDouble).run(List(1))
res0: Option[Double] = Some(1.0)

def mapF[N[_], C](f: (F[B]) ⇒ N[C]): Kleisli[N, A, C]

def mapK[G[_]](f: ~>[F, G]): Kleisli[G, A, B]

Modify the context F using transformation f.

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

val run: (A) ⇒ F[B]

def second[C](implicit F: Functor[F]): Kleisli[F, (C, A), (C, B)]

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

def tap(implicit F: Functor[F]): Kleisli[F, A, A]

Discard computed B and yield the input value.

def tapWith[C](f: (A, B) ⇒ C)(implicit F: Functor[F]): Kleisli[F, A, C]

Yield computed B combined with input value.

def tapWithF[C](f: (A, B) ⇒ F[C])(implicit F: FlatMap[F]): Kleisli[F, A, C]

def toReader: Reader[A, F[B]]

def traverse[G[_]](f: G[A])(implicit F: Applicative[F], G: Traverse[G]): F[G[B]]

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def transform[G[_]](f: FunctionK[F, G]): Kleisli[G, A, B]