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]

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

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]

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]

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]

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 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]