Invariant

cats.Invariant

See theInvariant companion object

trait Invariant[F[_]] extends Serializable

Must obey the laws defined in cats.laws.InvariantLaws.

Attributes

Companion:: object
Source:: Invariant.scala
Graph
Supertypes: trait Serializable
class Object
trait Matchable
class Any
Known subtypes: trait Contravariant[F]
trait ContravariantSemigroupal[F]
trait ContravariantMonoidal[F]
trait Functor[F]
trait Apply[F]
trait Applicative[F]
trait ApplicativeError[F, E]
trait MonadError[F, E]
trait CommutativeApplicative[F]
trait CommutativeMonad[F]
trait Monad[F]
trait Bimonad[F]
trait StackSafeMonad[F]
trait NonEmptyAlternative[F]
trait Alternative[F]
trait CommutativeApply[F]
trait CommutativeFlatMap[F]
trait FlatMap[F]
trait CoflatMap[F]
trait Comonad[F]
trait Distributive[F]
trait Traverse[F]
trait NonEmptyTraverse[F]
trait InvariantSemigroupal[F]
trait InvariantMonoidal[F]
Self type: Invariant[F]

Members list

Concise view

Value members

Abstract methods

Transform an F[A] into an F[B] by providing a transformation from A to B and one from B to A.

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

Attributes

Source:: Invariant.scala

Concrete methods

Compose Invariant F[_] and G[_] then produce Invariant[F[G[_]]] using their imap.

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)

Attributes

Source:: Invariant.scala

Compose Invariant F[_] and Contravariant G[_] then produce Invariant[F[G[_]]] using F's imap and G's contramap.

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

Attributes

Source:: Invariant.scala

Compose Invariant F[_] and Functor G[_] then produce Invariant[F[G[_]]] using F's imap and G's map.

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)

Attributes

Source:: Invariant.scala

Generated with