root/scalaz/Decidable

Decidable

trait Decidable[F[_]] extends Divisible[F] with InvariantAlt[F]

Coproduct analogue of Divide

https://hackage.haskell.org/package/contravariant-1.4.1/docs/Data-Functor-Contravariant-Divisible.html#t:Decidable

Companion
object
trait InvariantAlt[F]
trait Divisible[F]
trait Divide[F]
trait Contravariant[F]
class Object
trait Matchable
class Any

Type members

Classlikes

trait DecidableLaw extends DivisibleLaw

Inherited classlikes

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

Value members

Abstract methods

def choose2[Z, A1, A2](a1: => F[A1], a2: => F[A2])(f: Z => A1 \/ A2): F[Z]

Concrete methods

final
def choose[Z, A1, A2](a1: => F[A1], a2: => F[A2])(f: Z => A1 \/ A2): F[Z]
def choose1[Z, A1](a1: => F[A1])(f: Z => A1): F[Z]
def choose3[Z, A1, A2, A3](a1: => F[A1], a2: => F[A2], a3: => F[A3])(f: Z => A1 \/ A2 \/ A3): F[Z]
def choose4[Z, A1, A2, A3, A4](a1: => F[A1], a2: => F[A2], a3: => F[A3], a4: => F[A4])(f: Z => A1 \/ A2 \/ A3 \/ A4): F[Z]
final
def choosing2[Z, A1, A2](f: Z => A1 \/ A2)(implicit fa1: F[A1], fa2: F[A2]): F[Z]
final
def choosing3[Z, A1, A2, A3](f: Z => A1 \/ A2 \/ A3)(implicit fa1: F[A1], fa2: F[A2], fa3: F[A3]): F[Z]
final
def choosing4[Z, A1, A2, A3, A4](f: Z => A1 \/ A2 \/ A3 \/ A4)(implicit fa1: F[A1], fa2: F[A2], fa3: F[A3], fa4: F[A4]): F[Z]
override
def xcoproduct1[Z, A1](a1: => F[A1])(f: A1 => Z, g: Z => A1): F[Z]
Definition Classes
override
def xcoproduct2[Z, A1, A2](a1: => F[A1], a2: => F[A2])(f: A1 \/ A2 => Z, g: Z => A1 \/ A2): F[Z]
Definition Classes
override
def xcoproduct3[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 xcoproduct4[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
def conquer[A]: F[A]

Universally quantified instance of F[_]

Universally quantified instance of F[_]

Inherited from
Divisible
override
def contramap[A, B](fa: F[A])(f: B => A): F[B]
Definition Classes
Inherited from
Divisible
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
def divide2[A1, A2, Z](a1: => F[A1], a2: => F[A2])(f: Z => (A1, A2)): F[Z]
Inherited from
Divide
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 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 xcoderiving1[Z, A1](f: A1 => Z, g: Z => A1)(implicit a1: F[A1]): F[Z]
Inherited from
InvariantAlt
final
def xcoderiving2[Z, A1, A2](f: A1 \/ A2 => Z, g: Z => A1 \/ A2)(implicit a1: F[A1], a2: F[A2]): F[Z]
Inherited from
InvariantAlt
final
def xcoderiving3[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
InvariantAlt
final
def xcoderiving4[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
InvariantAlt
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
def xmap[A, B](fa: F[A], f: A => B, g: B => A): F[B]
Inherited from
Contravariant
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
override
def xproduct0[Z](z: => Z): F[Z]
Definition Classes
Inherited from
Divisible
override
def xproduct1[Z, A1](a1: => F[A1])(f: A1 => Z, g: Z => A1): F[Z]
Definition Classes
Inherited from
Divisible
override
def xproduct2[Z, A1, A2](a1: => F[A1], a2: => F[A2])(f: (A1, A2) => Z, g: Z => (A1, A2)): F[Z]
Definition Classes
Inherited from
Divisible
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
Inherited from
Divisible
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 from
Divisible

Concrete fields

Inherited fields

val divideSyntax: DivideSyntax[F]
Inherited from
Divide