trait Distributive[F[_]] extends Functor[F]
- Self Type
- Distributive[F]
- Annotations
- @implicitNotFound( ... ) @typeclass( ... , ... )
- Source
- Distributive.scala
- Alphabetic
- By Inheritance
- Distributive
- Functor
- Invariant
- Serializable
- Serializable
- AnyRef
- Any
- Hide All
- Show All
- Public
- All
Abstract Value Members
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 compose[G[_]](implicit G0: Distributive[G]): Distributive[[α]F[G[α]]]
-
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
-
def
cosequence[G[_], A](ga: G[F[A]])(implicit arg0: Functor[G]): F[G[A]]
Given a Functor G which wraps some distributive F, distribute F across the G.
-
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