trait Comonad[F[_]] extends CoflatMap[F]
Comonad
Comonad is the dual of Monad. Whereas Monads allow for the composition of effectful functions, Comonads allow for composition of functions that extract the value from their context.
Must obey the laws defined in cats.laws.ComonadLaws.
- Annotations
- @implicitNotFound( ... ) @typeclass( ... , ... )
- Source
- Comonad.scala
- Alphabetic
- By Inheritance
- Comonad
- CoflatMap
- Functor
- Invariant
- Serializable
- Serializable
- AnyRef
- Any
- Hide All
- Show All
- Public
- All
Abstract Value Members
-
abstract
def
coflatMap[A, B](fa: F[A])(f: (F[A]) ⇒ B): F[B]
coflatMapis the dual offlatMaponFlatMap.coflatMapis the dual offlatMaponFlatMap. It applies a value in a context to a function that takes a value in a context and returns a normal value.Example:
scala> import cats.implicits._ scala> import cats.CoflatMap scala> val fa = Some(3) scala> def f(a: Option[Int]): Int = a match { | case Some(x) => 2 * x | case None => 0 } scala> CoflatMap[Option].coflatMap(fa)(f) res0: Option[Int] = Some(6)
- Definition Classes
- CoflatMap
-
abstract
def
extract[A](x: F[A]): A
extractis the dual ofpureon Monad (viaApplicative) and extracts the value from its contextextractis the dual ofpureon Monad (viaApplicative) and extracts the value from its contextExample:
scala> import cats.Id scala> import cats.Comonad scala> val id: Id[Int] = 3 scala> Comonad[Id].extract(id) res0: cats.Id[Int] = 3
-
abstract
def
map[A, B](fa: F[A])(f: (A) ⇒ B): F[B]
- Definition Classes
- Functor
Concrete 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
as[A, B](fa: F[A], b: B): F[B]
Replaces the
Avalue inF[A]with the supplied value.Replaces the
Avalue inF[A]with the supplied value.Example:
scala> import cats.Functor scala> import cats.implicits.catsStdInstancesForList scala> Functor[List].as(List(1,2,3), "hello") res0: List[String] = List(hello, hello, hello)
- Definition Classes
- Functor
-
final
def
asInstanceOf[T0]: T0
- Definition Classes
- Any
-
def
clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( ... ) @native() @IntrinsicCandidate()
-
def
coflatten[A](fa: F[A]): F[F[A]]
coflattenis the dual offlattenonFlatMap.coflattenis the dual offlattenonFlatMap. Whereas flatten removes a layer ofF, coflatten adds a layer ofFExample:
scala> import cats.implicits._ scala> import cats.CoflatMap scala> val fa = Some(3) fa: Option[Int] = Some(3) scala> CoflatMap[Option].coflatten(fa) res0: Option[Option[Int]] = Some(Some(3))
- Definition Classes
- CoflatMap
-
def
compose[G[_]](implicit arg0: Functor[G]): Functor[[α]F[G[α]]]
- Definition Classes
- Functor
-
def
compose[G[_]](implicit arg0: Invariant[G]): Invariant[[α]F[G[α]]]
Compose Invariant
F[_]andG[_]then produceInvariant[F[G[_]]]using theirimap.Compose Invariant
F[_]andG[_]then produceInvariant[F[G[_]]]using theirimap.Example:
scala> import cats.implicits._ scala> import scala.concurrent.duration._ scala> val durSemigroupList: Semigroup[List[FiniteDuration]] = | Invariant[Semigroup].compose[List].imap(Semigroup[List[Long]])(Duration.fromNanos)(_.toNanos) scala> durSemigroupList.combine(List(2.seconds, 3.seconds), List(4.seconds)) res1: List[FiniteDuration] = List(2 seconds, 3 seconds, 4 seconds)
- Definition Classes
- Invariant
-
def
composeContravariant[G[_]](implicit arg0: Contravariant[G]): Contravariant[[α]F[G[α]]]
Compose Invariant
F[_]and ContravariantG[_]then produceInvariant[F[G[_]]]using F'simapand G'scontramap.Compose Invariant
F[_]and ContravariantG[_]then produceInvariant[F[G[_]]]using F'simapand G'scontramap.Example:
scala> import cats.implicits._ scala> import scala.concurrent.duration._ scala> type ToInt[T] = T => Int scala> val durSemigroupToInt: Semigroup[ToInt[FiniteDuration]] = | Invariant[Semigroup] | .composeContravariant[ToInt] | .imap(Semigroup[ToInt[Long]])(Duration.fromNanos)(_.toNanos) // semantically equal to (2.seconds.toSeconds.toInt + 1) + (2.seconds.toSeconds.toInt * 2) = 7 scala> durSemigroupToInt.combine(_.toSeconds.toInt + 1, _.toSeconds.toInt * 2)(2.seconds) res1: Int = 7
-
def
composeFunctor[G[_]](implicit arg0: Functor[G]): Invariant[[α]F[G[α]]]
Compose Invariant
F[_]and FunctorG[_]then produceInvariant[F[G[_]]]using F'simapand G'smap.Compose Invariant
F[_]and FunctorG[_]then produceInvariant[F[G[_]]]using F'simapand G'smap.Example:
scala> import cats.implicits._ scala> import scala.concurrent.duration._ scala> val durSemigroupList: Semigroup[List[FiniteDuration]] = | Invariant[Semigroup] | .composeFunctor[List] | .imap(Semigroup[List[Long]])(Duration.fromNanos)(_.toNanos) scala> durSemigroupList.combine(List(2.seconds, 3.seconds), List(4.seconds)) res1: List[FiniteDuration] = List(2 seconds, 3 seconds, 4 seconds)
- Definition Classes
- Invariant
-
final
def
eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
def
equals(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
final
def
fmap[A, B](fa: F[A])(f: (A) ⇒ B): F[B]
Alias for map, since map can't be injected as syntax if the implementing type already had a built-in
.mapmethod.Alias for map, since map can't be injected as syntax if the implementing type already had a built-in
.mapmethod.Example:
scala> import cats.implicits._ scala> val m: Map[Int, String] = Map(1 -> "hi", 2 -> "there", 3 -> "you") scala> m.fmap(_ ++ "!") res0: Map[Int,String] = Map(1 -> hi!, 2 -> there!, 3 -> you!)
- Definition Classes
- Functor
-
def
fproduct[A, B](fa: F[A])(f: (A) ⇒ B): F[(A, B)]
Tuple the values in fa with the result of applying a function with the value
Tuple the values in fa with the result of applying a function with the value
Example:
scala> import cats.Functor scala> import cats.implicits.catsStdInstancesForOption scala> Functor[Option].fproduct(Option(42))(_.toString) res0: Option[(Int, String)] = Some((42,42))
- Definition Classes
- Functor
-
def
fproductLeft[A, B](fa: F[A])(f: (A) ⇒ B): F[(B, A)]
Pair the result of function application with
A.Pair the result of function application with
A.Example:
scala> import cats.Functor scala> import cats.implicits.catsStdInstancesForOption scala> Functor[Option].fproductLeft(Option(42))(_.toString) res0: Option[(String, Int)] = Some((42,42))
- Definition Classes
- Functor
-
final
def
getClass(): Class[_]
- Definition Classes
- AnyRef → Any
- Annotations
- @native() @IntrinsicCandidate()
-
def
hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native() @IntrinsicCandidate()
-
def
ifF[A](fb: F[Boolean])(ifTrue: ⇒ A, ifFalse: ⇒ A): F[A]
Lifts
ifto FunctorLifts
ifto FunctorExample:
scala> import cats.Functor scala> import cats.implicits.catsStdInstancesForList scala> Functor[List].ifF(List(true, false, false))(1, 0) res0: List[Int] = List(1, 0, 0)
- Definition Classes
- Functor
- Annotations
- @noop()
-
def
imap[A, B](fa: F[A])(f: (A) ⇒ B)(g: (B) ⇒ A): F[B]
Transform an
F[A]into anF[B]by providing a transformation fromAtoBand one fromBtoA.Transform an
F[A]into anF[B]by providing a transformation fromAtoBand one fromBtoA.Example:
scala> import cats.implicits._ scala> import scala.concurrent.duration._ scala> val durSemigroup: Semigroup[FiniteDuration] = | Invariant[Semigroup].imap(Semigroup[Long])(Duration.fromNanos)(_.toNanos) scala> durSemigroup.combine(2.seconds, 3.seconds) res1: FiniteDuration = 5 seconds
-
final
def
isInstanceOf[T0]: Boolean
- Definition Classes
- Any
-
def
lift[A, B](f: (A) ⇒ B): (F[A]) ⇒ F[B]
Lift a function f to operate on Functors
Lift a function f to operate on Functors
Example:
scala> import cats.Functor scala> import cats.implicits.catsStdInstancesForOption scala> val o = Option(42) scala> Functor[Option].lift((x: Int) => x + 10)(o) res0: Option[Int] = Some(52)
- Definition Classes
- Functor
-
final
def
ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
final
def
notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native() @IntrinsicCandidate()
-
final
def
notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native() @IntrinsicCandidate()
-
final
def
synchronized[T0](arg0: ⇒ T0): T0
- Definition Classes
- AnyRef
-
def
toString(): String
- Definition Classes
- AnyRef → Any
-
def
tupleLeft[A, B](fa: F[A], b: B): F[(B, A)]
Tuples the
Avalue inF[A]with the suppliedBvalue, with theBvalue on the left.Tuples the
Avalue inF[A]with the suppliedBvalue, with theBvalue on the left.Example:
scala> import scala.collection.immutable.Queue scala> import cats.Functor scala> import cats.implicits.catsStdInstancesForQueue scala> Functor[Queue].tupleLeft(Queue("hello", "world"), 42) res0: scala.collection.immutable.Queue[(Int, String)] = Queue((42,hello), (42,world))
- Definition Classes
- Functor
-
def
tupleRight[A, B](fa: F[A], b: B): F[(A, B)]
Tuples the
Avalue inF[A]with the suppliedBvalue, with theBvalue on the right.Tuples the
Avalue inF[A]with the suppliedBvalue, with theBvalue on the right.Example:
scala> import scala.collection.immutable.Queue scala> import cats.Functor scala> import cats.implicits.catsStdInstancesForQueue scala> Functor[Queue].tupleRight(Queue("hello", "world"), 42) res0: scala.collection.immutable.Queue[(String, Int)] = Queue((hello,42), (world,42))
- Definition Classes
- Functor
-
def
unzip[A, B](fab: F[(A, B)]): (F[A], F[B])
Un-zips an
F[(A, B)]consisting of element pairs or Tuple2 into two separate F's tupled.Un-zips an
F[(A, B)]consisting of element pairs or Tuple2 into two separate F's tupled.NOTE: Check for effect duplication, possibly memoize before
scala> import cats.Functor scala> import cats.implicits.catsStdInstancesForList scala> Functor[List].unzip(List((1,2), (3, 4))) res0: (List[Int], List[Int]) = (List(1, 3),List(2, 4))
- Definition Classes
- Functor
- Annotations
- @noop()
-
def
void[A](fa: F[A]): F[Unit]
Empty the fa of the values, preserving the structure
Empty the fa of the values, preserving the structure
Example:
scala> import cats.Functor scala> import cats.implicits.catsStdInstancesForList scala> Functor[List].void(List(1,2,3)) res0: List[Unit] = List((), (), ())
- Definition Classes
- Functor
-
final
def
wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... ) @native()
-
final
def
wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
def
widen[A, B >: A](fa: F[A]): F[B]
Lifts natural subtyping covariance of covariant Functors.
Lifts natural subtyping covariance of covariant Functors.
NOTE: In certain (perhaps contrived) situations that rely on universal equality this can result in a
ClassCastException, because it is implemented as a type cast. It could be implemented asmap(identity), but according to the functor laws, that should be equal tofa, and a type cast is often much more performant. See this example ofwidencreating aClassCastException.Example:
scala> import cats.Functor scala> import cats.implicits.catsStdInstancesForOption scala> val s = Some(42) scala> Functor[Option].widen(s) res0: Option[Int] = Some(42)
- Definition Classes
- Functor