object Kleisli extends KleisliInstances with KleisliFunctions with KleisliFunctionsBinCompat with KleisliExplicitInstances with Serializable
- Source
- Kleisli.scala
- Alphabetic
- By Inheritance
- Kleisli
- Serializable
- KleisliExplicitInstances
- KleisliFunctionsBinCompat
- KleisliFunctions
- KleisliInstances
- KleisliInstances0
- KleisliInstances0_5
- KleisliInstances1
- KleisliInstances2
- KleisliInstances3
- KleisliInstances4
- KleisliInstances5
- KleisliInstances6
- KleisliInstances7
- KleisliInstances8
- KleisliInstances9
- AnyRef
- Any
- Hide All
- Show All
- Public
- Protected
Value Members
- final def !=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- final def ##: Int
- Definition Classes
- AnyRef → Any
- final def ==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- def applyK[F[_], A](a: A): ~>[[γ$0$]Kleisli[F, A, γ$0$], F]
Creates a
FunctionK
that transforms aKleisli[F, A, B]
into anF[B]
by applying the value of typea:A
.Creates a
FunctionK
that transforms aKleisli[F, A, B]
into anF[B]
by applying the value of typea:A
.scala> import cats.{~>}, cats.data.{Kleisli, EitherT} scala> def f(i: Int): Option[Either[Char, Char]] = if (i > 0) Some(Right('n')) else if (i < 0) Some(Left('z')) else None scala> type KOI[A] = Kleisli[Option, Int, A] scala> val b: KOI[Either[Char, Char]] = Kleisli[Option, Int, Either[Char, Char]](f _) scala> val nt: Kleisli[Option, Int, *] ~> Option = Kleisli.applyK[Option, Int](1) scala> nt(b) res0: Option[Either[Char, Char]] = Some(Right(n)) scala> type EKOIC[A] = EitherT[KOI, Char, A] scala> val c: EKOIC[Char] = EitherT[KOI, Char, Char](b) scala> c.mapK(nt).value res1: Option[Either[Char, Char]] = Some(Right(n)) scala> val ntz = Kleisli.applyK[Option, Int](0) scala> c.mapK(ntz).value res2: Option[Either[Char, Char]] = None
- final def asInstanceOf[T0]: T0
- Definition Classes
- Any
- def ask[F[_], A](implicit F: Applicative[F]): Kleisli[F, A, A]
Creates a Kleisli arrow which can lift an
A
into applicative contextF
.Creates a Kleisli arrow which can lift an
A
into applicative contextF
. This is distinct from pure in that the input is what is lifted (and not ignored).scala> Kleisli.ask[Option, Int].run(1) res0: Option[Int]: Some(1)
- Definition Classes
- KleisliFunctions
- implicit def catsDataAlignForKleisli[F[_], R](implicit evFunctor: Functor[[γ$36$]Kleisli[F, R, γ$36$]], evAlign: Align[F]): Align[[γ$37$]Kleisli[F, R, γ$37$]]
- Definition Classes
- KleisliInstances0_5
- implicit def catsDataAlternativeForKleisli[F[_], A](implicit F0: Alternative[F]): Alternative[[γ$55$]Kleisli[F, A, γ$55$]]
- Definition Classes
- KleisliInstances2
- implicit def catsDataApplicativeErrorForKleisli[F[_], E, A](implicit F0: ApplicativeError[F, E]): ApplicativeError[[γ$69$]Kleisli[F, A, γ$69$], E]
- Definition Classes
- KleisliInstances5
- implicit def catsDataApplicativeForKleisli[F[_], A](implicit A: Applicative[F]): Applicative[[γ$70$]Kleisli[F, A, γ$70$]]
- Definition Classes
- KleisliInstances6
- implicit def catsDataApplyForKleisli[F[_], A](implicit A: Apply[F]): Apply[[γ$71$]Kleisli[F, A, γ$71$]]
- Definition Classes
- KleisliInstances7
- implicit def catsDataArrowChoiceForKleisli[F[_]](implicit M: Monad[F]): ArrowChoice[[β$29$, γ$30$]Kleisli[F, β$29$, γ$30$]]
- Definition Classes
- KleisliInstances0_5
- implicit def catsDataChoiceForKleisli[F[_]](implicit M: Monad[F]): Choice[[β$59$, γ$60$]Kleisli[F, β$59$, γ$60$]]
- Definition Classes
- KleisliInstances3
- implicit val catsDataChoiceForKleisliId: Choice[[β$61$, γ$62$]Kleisli[[A]A, β$61$, γ$62$]]
- Definition Classes
- KleisliInstances3
- implicit def catsDataCommutativeArrowForKleisli[F[_]](implicit M: CommutativeMonad[F]): CommutativeArrow[[β$22$, γ$23$]Kleisli[F, β$22$, γ$23$]] with ArrowChoice[[β$24$, γ$25$]Kleisli[F, β$24$, γ$25$]]
- Definition Classes
- KleisliInstances0
- implicit val catsDataCommutativeArrowForKleisliId: CommutativeArrow[[β$17$, γ$18$]Kleisli[[A]A, β$17$, γ$18$]]
- Definition Classes
- KleisliInstances
- implicit def catsDataCommutativeFlatMapForKleisli[F[_], A](implicit F0: CommutativeFlatMap[F]): CommutativeFlatMap[[γ$57$]Kleisli[F, A, γ$57$]]
- Definition Classes
- KleisliInstances3
- implicit def catsDataCommutativeMonadForKleisli[F[_], A](implicit F0: CommutativeMonad[F]): CommutativeMonad[[γ$26$]Kleisli[F, A, γ$26$]]
- Definition Classes
- KleisliInstances0
- implicit def catsDataComposeForKleisli[F[_]](implicit FM: FlatMap[F]): Compose[[β$63$, γ$64$]Kleisli[F, β$63$, γ$64$]]
- Definition Classes
- KleisliInstances3
- implicit def catsDataContravariantForKleisli[F[_], C]: Contravariant[[β$53$]Kleisli[F, β$53$, C]]
- Definition Classes
- KleisliInstances1
- implicit def catsDataContravariantMonoidalForKleisli[F[_], A](implicit F0: ContravariantMonoidal[F]): ContravariantMonoidal[[γ$31$]Kleisli[F, A, γ$31$]]
- Definition Classes
- KleisliInstances0_5
- implicit def catsDataDeferForKleisli[F[_], A](implicit F: Defer[F]): Defer[[γ$19$]Kleisli[F, A, γ$19$]]
- Definition Classes
- KleisliInstances
- implicit def catsDataDistributiveForKleisli[F[_], R](implicit F0: Distributive[F]): Distributive[[γ$72$]Kleisli[F, R, γ$72$]]
- Definition Classes
- KleisliInstances8
- implicit def catsDataFlatMapForKleisli[F[_], A](implicit FM: FlatMap[F]): FlatMap[[γ$68$]Kleisli[F, A, γ$68$]]
- Definition Classes
- KleisliInstances4
- implicit def catsDataFunctorFilterForKleisli[F[_], A](implicit ev: FunctorFilter[F]): FunctorFilter[[γ$21$]Kleisli[F, A, γ$21$]]
- Definition Classes
- KleisliInstances
- implicit def catsDataFunctorForKleisli[F[_], A](implicit F0: Functor[F]): Functor[[γ$73$]Kleisli[F, A, γ$73$]]
- Definition Classes
- KleisliInstances9
- implicit def catsDataMonadErrorForKleisli[F[_], A, E](implicit ME: MonadError[F, E]): MonadError[[γ$28$]Kleisli[F, A, γ$28$], E]
- Definition Classes
- KleisliInstances0_5
- implicit def catsDataMonadForKleisli[F[_], A](implicit M: Monad[F]): Monad[[γ$39$]Kleisli[F, A, γ$39$]]
- Definition Classes
- KleisliInstances1
- implicit def catsDataMonadForKleisliId[A]: CommutativeMonad[[γ$16$]Kleisli[[A]A, A, γ$16$]]
- Definition Classes
- KleisliInstances
- implicit def catsDataMonoidForKleisli[F[_], A, B](implicit FB0: Monoid[F[B]]): Monoid[Kleisli[F, A, B]]
- Definition Classes
- KleisliInstances0_5
- implicit def catsDataMonoidKForKleisli[F[_], A](implicit F0: MonoidK[F]): MonoidK[[γ$56$]Kleisli[F, A, γ$56$]]
- Definition Classes
- KleisliInstances3
- implicit def catsDataParallelForKleisli[M[_], A](implicit P: Parallel[M]): Aux[[γ$40$]Kleisli[M, A, γ$40$], [γ$41$]Kleisli[Parallel.F, A, γ$41$]]
- Definition Classes
- KleisliInstances1
- implicit def catsDataRepresentableForKleisli[M[_], R, E](implicit R: Aux[M, R], FK: Functor[[γ$32$]Kleisli[M, E, γ$32$]]): Aux[[γ$33$]Kleisli[M, E, γ$33$], (E, R)]
Witness for: Kleisli[M, E, A] <-> (E, R) => A if M is Representable
Witness for: Kleisli[M, E, A] <-> (E, R) => A if M is Representable
- Definition Classes
- KleisliInstances0_5
- implicit def catsDataSemigroupForKleisli[F[_], A, B](implicit FB0: Semigroup[F[B]]): Semigroup[Kleisli[F, A, B]]
- Definition Classes
- KleisliInstances3
- implicit def catsDataSemigroupKForKleisli[F[_], A](implicit F0: SemigroupK[F]): SemigroupK[[γ$67$]Kleisli[F, A, γ$67$]]
- Definition Classes
- KleisliInstances4
- implicit def catsDataStrongForKleisli[F[_]](implicit F0: Functor[F]): Strong[[β$65$, γ$66$]Kleisli[F, β$65$, γ$66$]]
- Definition Classes
- KleisliInstances3
- def clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.CloneNotSupportedException]) @native()
- def endoMonoidK[F[_]](implicit M: Monad[F]): MonoidK[[α]Kleisli[F, α, α]]
- Definition Classes
- KleisliExplicitInstances
- def endoSemigroupK[F[_]](implicit FM: FlatMap[F]): SemigroupK[[α]Kleisli[F, α, α]]
- Definition Classes
- KleisliExplicitInstances
- final def eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- def equals(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef → Any
- def finalize(): Unit
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.Throwable])
- def fromFunction[M[_], R]: KleisliFromFunctionPartiallyApplied[M, R]
Lifts a function to a Kleisli.
Lifts a function to a Kleisli.
scala> import cats.data.Kleisli scala> val stringify = Kleisli.fromFunction[Option, Int].apply(_.toString) scala> stringify.run(42) res0: Option[String] = Some(42)
- Definition Classes
- KleisliFunctions
- final def getClass(): Class[_ <: AnyRef]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- def hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- final def isInstanceOf[T0]: Boolean
- Definition Classes
- Any
- def liftF[F[_], A, B](x: F[B]): Kleisli[F, A, B]
Creates a Kleisli that ignores its input
A
and returns the givenF[B]
.Creates a Kleisli that ignores its input
A
and returns the givenF[B]
.scala> import cats.data.Kleisli, cats.implicits._ scala> val takeHead = Kleisli((_:List[Int]).headOption) scala> val makeList = Kleisli.liftF[Option, Unit, List[Int]](Some(List(1,2,3))) scala> (makeList andThen takeHead).run(()) res0: Option[Int] = Some(1)
- Definition Classes
- KleisliFunctions
- def liftFunctionK[F[_], G[_], A](f: ~>[F, G]): ~>[[γ$8$]Kleisli[F, A, γ$8$], [γ$9$]Kleisli[G, A, γ$9$]]
Lifts a natural transformation of effects within a Kleisli to a transformation of Kleislis.
Lifts a natural transformation of effects within a Kleisli to a transformation of Kleislis.
Equivalent to running
mapK(f) on a Kleisli.
scala> import cats._, data._ scala> val f: (List ~> Option) = λ[List ~> Option](_.headOption) scala> val k: Kleisli[List, String, Char] = Kleisli(_.toList) scala> k.run("foo") res0: List[Char] = List(f, o, o) scala> val k2: Kleisli[Option, String, Char] = Kleisli.liftFunctionK(f)(k) scala> k2.run("foo") res1: Option[Char] = Some(f)
- Definition Classes
- KleisliFunctionsBinCompat
- def liftK[F[_], A]: ~>[F, [γ$6$]Kleisli[F, A, γ$6$]]
Same as liftF, but expressed as a FunctionK for use with mapK
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)
- Definition Classes
- KleisliFunctions
- def local[M[_], A, R](f: (R) => R)(fa: Kleisli[M, R, A]): Kleisli[M, R, A]
Modifies the input environment with
f
, without changing the input type of the Kleisli.Modifies the input environment with
f
, without changing the input type of the Kleisli.scala> import cats.data.Kleisli scala> val takeHead = Kleisli[Option, List[Int], Int](_.headOption) scala> Kleisli.local[Option, Int, List[Int]](1 :: _)(takeHead).run(List(2,3)) res0: Option[Int] = Some(1)
- Definition Classes
- KleisliFunctions
- def localK[F[_], A, C](f: (C) => A): ~>[[γ$2$]Kleisli[F, A, γ$2$], [γ$3$]Kleisli[F, C, γ$3$]]
Creates a
FunctionK
that transforms aKleisli[F, A, B]
into anKleisli[F, C, B]
usingC => A
.Creates a
FunctionK
that transforms aKleisli[F, A, B]
into anKleisli[F, C, B]
usingC => A
.scala> import cats.{~>}, cats.data.Kleisli scala> def nonEmpty(s: String): Option[String] = Option(s).filter(_.nonEmpty) scala> type KOS[A] = Kleisli[Option, String, A] scala> type KOLS[A] = Kleisli[Option, List[String], A] scala> val size: KOS[Int] = Kleisli(s => nonEmpty(s).map(_.size)) scala> val exclaim: KOS[String] = Kleisli(s => nonEmpty(s).map(nes => s"${nes.toUpperCase}!")) scala> size("boo") res0: Option[Int] = Some(3) scala> exclaim("boo") res1: Option[String] = Some(BOO!) scala> val mkStringK: KOS ~> KOLS = Kleisli.localK(_.mkString) scala> mkStringK(size)(List("foo", "bar", "baz")) res2: Option[Int] = Some(9) scala> mkStringK(exclaim)(List("foo", "bar", "baz")) res3: Option[String] = Some(FOOBARBAZ!)
- final def ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- final def notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- final def notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- def pure[F[_], A, B](x: B)(implicit F: Applicative[F]): Kleisli[F, A, B]
Creates a Kleisli arrow ignoring its input and lifting the given
B
into applicative contextF
.Creates a Kleisli arrow ignoring its input and lifting the given
B
into applicative contextF
.scala> import cats.data.Kleisli, cats.implicits._ scala> val pureOpt = Kleisli.pure[Option, Unit, String]("beam me up!") scala> pureOpt.run(()) res0: Option[String] = Some(beam me up!)
- Definition Classes
- KleisliFunctions
- final def synchronized[T0](arg0: => T0): T0
- Definition Classes
- AnyRef
- def toString(): String
- Definition Classes
- AnyRef → Any
- final def wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException]) @native()