root/scalaz/IsomorphismDivisible

IsomorphismDivisible

trait IsomorphismDivisible[F[_], G[_]] extends Divisible[F] with IsomorphismDivide[F, G] with IsomorphismInvariantApplicative[F, G]
trait Divisible[F]
trait Divide[F]
trait Contravariant[F]
class Object
trait Matchable
class Any

Type members

Inherited classlikes

trait ContravariantLaw
Inherited from
Contravariant
trait DivideLaw
Inherited from
Divide
trait DivisibleLaw
Inherited from
Divisible
trait InvariantFunctorLaw
Inherited from
InvariantFunctor

Value members

Concrete methods

override
def conquer[A]: F[A]
Definition Classes
override
def xproduct0[Z](z: => Z): F[Z]
override
def xproduct1[Z, A1](a1: => F[A1])(f: A1 => Z, g: Z => A1): F[Z]
Definition Classes
override
def xproduct2[Z, A1, A2](a1: => F[A1], a2: => F[A2])(f: (A1, A2) => Z, g: Z => (A1, A2)): F[Z]
override
def xproduct3[Z, A1, A2, A3](a1: => F[A1], a2: => F[A2], a3: => F[A3])(f: (A1, A2, A3) => Z, g: Z => (A1, A2, A3)): F[Z]
Definition Classes
override
def xproduct4[Z, A1, A2, A3, A4](a1: => F[A1], a2: => F[A2], a3: => F[A3], a4: => F[A4])(f: (A1, A2, A3, A4) => Z, g: Z => (A1, A2, A3, A4)): F[Z]
Definition Classes

Inherited methods

def compose[G[_]](implicit G0: Contravariant[G]): Functor[[α] =>> F[G[α]]]

The composition of Contravariant F and G, [x]F[G[x]], is covariant.

The composition of Contravariant F and G, [x]F[G[x]], is covariant.

Inherited from
Contravariant
override
def contramap[A, B](r: F[A])(f: B => A): F[B]
final
def divide[A, B, C](fa: => F[A], fb: => F[B])(f: C => (A, B)): F[C]
Inherited from
Divide
final
def divide1[A1, Z](a1: F[A1])(f: Z => A1): F[Z]
Inherited from
Divide
override
def divide2[A, B, C](fa: => F[A], fb: => F[B])(f: C => (A, B)): F[C]
Definition Classes
Inherited from
IsomorphismDivide
def divide3[A1, A2, A3, Z](a1: => F[A1], a2: => F[A2], a3: => F[A3])(f: Z => (A1, A2, A3)): F[Z]
Inherited from
Divide
def divide4[A1, A2, A3, A4, Z](a1: => F[A1], a2: => F[A2], a3: => F[A3], a4: => F[A4])(f: Z => (A1, A2, A3, A4)): F[Z]
Inherited from
Divide
def divideLaw: DivideLaw
Inherited from
Divide
final
def dividing1[A1, Z](f: Z => A1)(implicit a1: F[A1]): F[Z]
Inherited from
Divide
final
def dividing2[A1, A2, Z](f: Z => (A1, A2))(implicit a1: F[A1], a2: F[A2]): F[Z]
Inherited from
Divide
final
def dividing3[A1, A2, A3, Z](f: Z => (A1, A2, A3))(implicit a1: F[A1], a2: F[A2], a3: F[A3]): F[Z]
Inherited from
Divide
final
def dividing4[A1, A2, A3, A4, Z](f: Z => (A1, A2, A3, A4))(implicit a1: F[A1], a2: F[A2], a3: F[A3], a4: F[A4]): F[Z]
Inherited from
Divide
def icompose[G[_]](implicit G0: Functor[G]): Contravariant[[α] =>> F[G[α]]]

The composition of Contravariant F and Functor G, [x]F[G[x]], is contravariant.

The composition of Contravariant F and Functor G, [x]F[G[x]], is contravariant.

Inherited from
Contravariant
def iso: IsoFunctor[F, G]
def narrow[A, B](fa: F[A])(implicit ev: Liskov[B, A]): F[B]
Inherited from
Contravariant
def product[G[_]](implicit G0: Contravariant[G]): Contravariant[[α] =>> (F[α], G[α])]

The product of Contravariant F and G, [x](F[x], G[x]]), is contravariant.

The product of Contravariant F and G, [x](F[x], G[x]]), is contravariant.

Inherited from
Contravariant
def tuple2[A1, A2](a1: => F[A1], a2: => F[A2]): F[(A1, A2)]
Inherited from
Divide
final
def xderiving0[Z](z: => Z): F[Z]
Inherited from
InvariantApplicative
final
def xderiving1[Z, A1](f: A1 => Z, g: Z => A1)(implicit a1: F[A1]): F[Z]
Inherited from
InvariantApplicative
final
def xderiving2[Z, A1, A2](f: (A1, A2) => Z, g: Z => (A1, A2))(implicit a1: F[A1], a2: F[A2]): F[Z]
Inherited from
InvariantApplicative
final
def xderiving3[Z, A1, A2, A3](f: (A1, A2, A3) => Z, g: Z => (A1, A2, A3))(implicit a1: F[A1], a2: F[A2], a3: F[A3]): F[Z]
Inherited from
InvariantApplicative
final
def xderiving4[Z, A1, A2, A3, A4](f: (A1, A2, A3, A4) => Z, g: Z => (A1, A2, A3, A4))(implicit a1: F[A1], a2: F[A2], a3: F[A3], a4: F[A4]): F[Z]
Inherited from
InvariantApplicative
override
def xmap[A, B](ma: F[A], f: A => B, g: B => A): F[B]
def xmapb[A, B](ma: F[A])(b: Bijection[A, B]): F[B]

Converts ma to a value of type F[B] using the provided bijection.

Converts ma to a value of type F[B] using the provided bijection.

Inherited from
InvariantFunctor
def xmapi[A, B](ma: F[A])(iso: IsoSet[A, B]): F[B]

Converts ma to a value of type F[B] using the provided isomorphism.

Converts ma to a value of type F[B] using the provided isomorphism.

Inherited from
InvariantFunctor

Inherited fields

val divideSyntax: DivideSyntax[F]
Inherited from
Divide

Implicits

Implicits

implicit
def G: Divisible[G]