Add Decidable

build.sbt

@@ -732,7 +732,7 @@ def commonScalacOptions(scalaVersion: String) =
     "-language:implicitConversions",
     "-language:experimental.macros",
     "-unchecked",
-    "-Ywarn-dead-code",
+    //"-Ywarn-dead-code",
     "-Ywarn-numeric-widen",
     "-Ywarn-value-discard",
     "-Xfuture"

core/src/main/scala/cats/Applicative.scala

@@ -137,6 +137,12 @@ import simulacrum.typeclass
       val G = ContravariantMonoidal[G]
     }
 
+  def composeDecideable[G[_]: Decideable]: Decideable[λ[α => F[G[α]]]] =
+    new ComposedApplicativeDecideable[F, G] {
+      val F = self
+      val G = Decideable[G]
+    }
+
   /**
    * Returns the given argument (mapped to Unit) if `cond` is `false`,
    * otherwise, unit lifted into F.

core/src/main/scala/cats/Composed.scala

@@ -131,6 +131,16 @@ private[cats] trait ComposedContravariantCovariant[F[_], G[_]] extends Contravar
     F.contramap(fga)(gb => G.map(gb)(f))
 }
 
+private[cats] trait ComposedApplicativeDecideable[F[_], G[_]]
+    extends Decideable[λ[α => F[G[α]]]]
+    with ComposedApplicativeContravariantMonoidal[F, G] { outer =>
+  def F: Applicative[F]
+  def G: Decideable[G]
+
+  def sum[A, B](fa: F[G[A]], fb: F[G[B]]): F[G[Either[A, B]]] =
+    F.map(F.product(fa, fb))(Function.tupled(G.sum))
+}
+
 private[cats] trait ComposedApplicativeContravariantMonoidal[F[_], G[_]]
     extends ContravariantMonoidal[λ[α => F[G[α]]]] { outer =>
   def F: Applicative[F]

core/src/main/scala/cats/Decideable.scala

@@ -0,0 +1,27 @@
+package cats
+
+import simulacrum.typeclass
+
+/**
+ * [[Decideable]] functors are functors that supply
+ * a `decide` operation allowing choices to be made.
+ *
+ * This is comparable to [[Alternative]] in the
+ * covariant case.
+ *
+ * Must obey laws in cats.laws.DecideableLaws.
+ *
+ * Based on ekmett's contravariant library:
+ * https://hackage.haskell.org/package/contravariant-1.4/docs/Data-Functor-Contravariant-Divisible.html#g:2
+ */
+@typeclass trait Decideable[F[_]] extends ContravariantMonoidal[F] {
+  def sum[A, B](fa: F[A], fb: F[B]): F[Either[A, B]]
+
+  def decide[A, B, C](fa: F[A], fb: F[B])(f: C => Either[A, B]): F[C] =
+    contramap(sum(fa, fb))(f)
+
+  def chosen[B, C](fb: F[B], fc: F[C]): F[Either[B, C]] =
+    decide(fb, fc)(identity[Either[B, C]])
+
+  def zero: F[Nothing] = trivial[Nothing]
+}

core/src/main/scala/cats/data/Const.scala

@@ -35,7 +35,7 @@ final case class Const[A, B](getConst: A) {
     s"Const(${A.show(getConst)})"
 }
 
-object Const extends ConstInstances {
+object Const extends ConstInstances with ConstInstancesBinCompat0 {
   def empty[A, B](implicit A: Monoid[A]): Const[A, B] =
     Const(A.empty)
 
@@ -121,7 +121,6 @@ sealed abstract private[data] class ConstInstances extends ConstInstances0 {
 }
 
 sealed abstract private[data] class ConstInstances0 extends ConstInstances1 {
-
   implicit def catsDataContravariantMonoidalForConst[D: Monoid]: ContravariantMonoidal[Const[D, ?]] =
     new ContravariantMonoidal[Const[D, ?]] {
       override def unit = Const.empty[D, Unit]
@@ -179,6 +178,20 @@ sealed abstract private[data] class ConstInstances4 {
     new ConstContravariant[C] {}
 }
 
+trait ConstInstancesBinCompat0 {
+  implicit def catsDataDecideableForConst[D: Monoid]: Decideable[Const[D, ?]] =
+    new Decideable[Const[D, ?]] {
+      override def unit = Const.empty[D, Unit]
+      override def contramap[A, B](fa: Const[D, A])(f: B => A): Const[D, B] =
+        fa.retag[B]
+      override def product[A, B](fa: Const[D, A], fb: Const[D, B]): Const[D, (A, B)] =
+        fa.retag[(A, B)].combine(fb.retag[(A, B)])
+      def sum[A, B](fa: Const[D, A], fb: Const[D, B]): Const[D, Either[A, B]] =
+        fa.retag[Either[A, B]].combine(fb.retag[Either[A, B]])
+    }
+
+}
+
 sealed private[data] trait ConstFunctor[C] extends Functor[Const[C, ?]] {
   def map[A, B](fa: Const[C, A])(f: A => B): Const[C, B] =
     fa.retag[B]

core/src/main/scala/cats/data/IdT.scala

@@ -73,6 +73,13 @@ sealed private[data] trait IdTApplicative[F[_]] extends Applicative[IdT[F, ?]] w
   def pure[A](a: A): IdT[F, A] = IdT.pure(a)
 }
 
+sealed private[data] trait IdTDecideable[F[_]] extends Decideable[IdT[F, ?]] with IdTContravariantMonoidal[F] {
+  implicit val F0: Decideable[F]
+
+  override def sum[A, B](fa: IdT[F, A], fb: IdT[F, B]): IdT[F, Either[A, B]] =
+    IdT(F0.sum(fa.value, fb.value))
+}
+
 sealed private[data] trait IdTContravariantMonoidal[F[_]] extends ContravariantMonoidal[IdT[F, ?]] {
   implicit val F0: ContravariantMonoidal[F]
 
@@ -148,6 +155,7 @@ sealed abstract private[data] class IdTInstances8 {
 sealed abstract private[data] class IdTInstances7 extends IdTInstances8 {
   implicit def catsDataCommutativeMonadForIdT[F[_]](implicit F: CommutativeMonad[F]): CommutativeMonad[IdT[F, ?]] =
     new IdTMonad[F] with CommutativeMonad[IdT[F, ?]] { implicit val F0: CommutativeMonad[F] = F }
+
 }
 
 sealed abstract private[data] class IdTInstances6 extends IdTInstances7 {
@@ -160,6 +168,11 @@ sealed abstract private[data] class IdTInstances6 extends IdTInstances7 {
 sealed abstract private[data] class IdTInstances5 extends IdTInstances6 {
   implicit def catsDataFunctorForIdT[F[_]](implicit F: Functor[F]): Functor[IdT[F, ?]] =
     new IdTFunctor[F] { implicit val F0: Functor[F] = F }
+
+  implicit def catsDataDecideableForIdT[F[_]](
+    implicit F: Decideable[F]
+  ): Decideable[IdT[F, ?]] =
+    new IdTDecideable[F] { implicit val F0: Decideable[F] = F }
 }
 
 sealed abstract private[data] class IdTInstances4 extends IdTInstances5 {

core/src/main/scala/cats/data/Kleisli.scala

@@ -184,6 +184,10 @@ sealed abstract private[data] class KleisliInstances0 extends KleisliInstances0_
       implicit def F: Monad[F] = F0
     }
 
+  implicit def catsDataDecideableForKleisli[F[_], A](
+    implicit F0: Decideable[F]
+  ): Decideable[Kleisli[F, A, ?]] =
+    new KleisliDecideable[F, A] { def F: Decideable[F] = F0 }
 }
 
 sealed abstract private[data] class KleisliInstances0_5 extends KleisliInstances1 {
@@ -419,6 +423,15 @@ private[data] trait KleisliAlternative[F[_], A]
   implicit def F: Alternative[F]
 }
 
+sealed private[data] trait KleisliDecideable[F[_], D]
+    extends Decideable[Kleisli[F, D, ?]]
+    with KleisliContravariantMonoidal[F, D] {
+  implicit def F: Decideable[F]
+
+  def sum[A, B](fa: Kleisli[F, D, A], fb: Kleisli[F, D, B]): Kleisli[F, D, Either[A, B]] =
+    Kleisli(d => F.sum(fa.run(d), fb.run(d)))
+}
+
 sealed private[data] trait KleisliContravariantMonoidal[F[_], D] extends ContravariantMonoidal[Kleisli[F, D, ?]] {
   implicit def F: ContravariantMonoidal[F]
 

core/src/main/scala/cats/data/Nested.scala

@@ -43,10 +43,10 @@ sealed abstract private[data] class NestedInstances extends NestedInstances0 {
       val FG: NonEmptyTraverse[λ[α => F[G[α]]]] = NonEmptyTraverse[F].compose[G]
     }
 
-  implicit def catsDataContravariantMonoidalForApplicativeForNested[F[_]: Applicative, G[_]: ContravariantMonoidal]
-    : ContravariantMonoidal[Nested[F, G, ?]] =
-    new NestedContravariantMonoidal[F, G] with NestedContravariant[F, G] {
-      val FG: ContravariantMonoidal[λ[α => F[G[α]]]] = Applicative[F].composeContravariantMonoidal[G]
+  implicit def catsDataDecideableForApplicativeForNested[F[_]: Applicative, G[_]: Decideable]
+    : Decideable[Nested[F, G, ?]] =
+    new NestedDecideable[F, G] with NestedContravariant[F, G] {
+      val FG: Decideable[λ[α => F[G[α]]]] = Applicative[F].composeDecideable[G]
     }
 
   implicit def catsDataDeferForNested[F[_], G[_]](implicit F: Defer[F]): Defer[Nested[F, G, ?]] =
@@ -75,6 +75,12 @@ sealed abstract private[data] class NestedInstances0 extends NestedInstances1 {
       implicit val F: Functor[F] = F0
       implicit val G: FunctorFilter[G] = G0
     }
+
+  implicit def catsDataContravariantMonoidalForApplicativeForNested[F[_]: Applicative, G[_]: ContravariantMonoidal]
+    : ContravariantMonoidal[Nested[F, G, ?]] =
+    new NestedContravariantMonoidal[F, G] with NestedContravariant[F, G] {
+      val FG: ContravariantMonoidal[λ[α => F[G[α]]]] = Applicative[F].composeContravariantMonoidal[G]
+    }
 }
 
 sealed abstract private[data] class NestedInstances1 extends NestedInstances2 {
@@ -329,6 +335,15 @@ private[data] trait NestedContravariant[F[_], G[_]] extends Contravariant[Nested
     Nested(FG.contramap(fga.value)(f))
 }
 
+private[data] trait NestedDecideable[F[_], G[_]]
+    extends Decideable[Nested[F, G, ?]]
+    with NestedContravariantMonoidal[F, G] {
+  def FG: Decideable[λ[α => F[G[α]]]]
+
+  def sum[A, B](fa: Nested[F, G, A], fb: Nested[F, G, B]): Nested[F, G, Either[A, B]] =
+    Nested(FG.sum(fa.value, fb.value))
+}
+
 private[data] trait NestedContravariantMonoidal[F[_], G[_]] extends ContravariantMonoidal[Nested[F, G, ?]] {
   def FG: ContravariantMonoidal[λ[α => F[G[α]]]]
 

core/src/main/scala/cats/data/Op.scala

@@ -20,13 +20,29 @@ sealed abstract private[data] class OpInstances extends OpInstances0 {
   implicit def catsDataCategoryForOp[Arr[_, _]](implicit ArrC: Category[Arr]): Category[Op[Arr, ?, ?]] =
     new OpCategory[Arr] { def Arr: Category[Arr] = ArrC }
 
+  implicit def catsDataDecideableForOp[Arr[_, _], R](implicit ArrC: ArrowChoice[Arr],
+                                                     monn: Monoid[R]): Decideable[Op[Arr, R, ?]] =
+    new OpDecideable[Arr, R] {
+      def Arr: ArrowChoice[Arr] = ArrC
+      def M: Monoid[R] = monn
+    }
+
   implicit def catsKernelEqForOp[Arr[_, _], A, B](implicit ArrEq: Eq[Arr[B, A]]): Eq[Op[Arr, A, B]] =
     new OpEq[Arr, A, B] { def Arr: Eq[Arr[B, A]] = ArrEq }
 }
 
-sealed abstract private[data] class OpInstances0 {
+sealed abstract private[data] class OpInstances0 extends OpInstances1 {
   implicit def catsDataComposeForOp[Arr[_, _]](implicit ArrC: Compose[Arr]): Compose[Op[Arr, ?, ?]] =
     new OpCompose[Arr] { def Arr: Compose[Arr] = ArrC }
+
+  implicit def catsDataContravariantMonoidalForOp[Arr[_, _], R](implicit ArrC: Arrow[Arr],
+                                                                M0: Monoid[R]): ContravariantMonoidal[Op[Arr, R, ?]] =
+    new OpContravariantMonoidal[Arr, R] { def Arr = ArrC; def M = M0 }
+}
+
+sealed abstract private[data] class OpInstances1 {
+  implicit def catsDataContravariantForOp[Arr[_, _], R](implicit ArrC: Arrow[Arr]): Contravariant[Op[Arr, R, ?]] =
+    new OpContravariant[Arr, R] { def Arr = ArrC }
 }
 
 private[data] trait OpCategory[Arr[_, _]] extends Category[Op[Arr, ?, ?]] with OpCompose[Arr] {
@@ -42,6 +58,34 @@ private[data] trait OpCompose[Arr[_, _]] extends Compose[Op[Arr, ?, ?]] {
     f.compose(g)
 }
 
+private[data] trait OpDecideable[Arr[_, _], R] extends Decideable[Op[Arr, R, ?]] with OpContravariantMonoidal[Arr, R] {
+  implicit def Arr: ArrowChoice[Arr]
+  implicit def M: Monoid[R]
+
+  def sum[A, B](fa: Op[Arr, R, A], fb: Op[Arr, R, B]): Op[Arr, R, Either[A, B]] =
+    Op(Arr.choice(fa.run, fb.run))
+}
+
+private[data] trait OpContravariantMonoidal[Arr[_, _], R]
+    extends OpContravariant[Arr, R]
+    with ContravariantMonoidal[Op[Arr, R, ?]] {
+  implicit def Arr: Arrow[Arr]
+  implicit def M: Monoid[R]
+
+  def unit: Op[Arr, R, Unit] =
+    Op(Arr.lift(Function.const(M.empty)))
+
+  def product[A, B](fa: Op[Arr, R, A], fb: Op[Arr, R, B]): Op[Arr, R, (A, B)] =
+    Op(Arr.compose(Arr.lift((M.combine _).tupled), Arr.split(fa.run, fb.run)))
+}
+
+private[data] trait OpContravariant[Arr[_, _], R] extends Contravariant[Op[Arr, R, ?]] {
+  implicit def Arr: Arrow[Arr]
+
+  def contramap[A, B](fa: Op[Arr, R, A])(f: B => A): Op[Arr, R, B] =
+    Op(Arr.compose(fa.run, Arr.lift(f)))
+}
+
 private[data] trait OpEq[Arr[_, _], A, B] extends Eq[Op[Arr, A, B]] {
   implicit def Arr: Eq[Arr[B, A]]
 

core/src/main/scala/cats/data/OptionT.scala

@@ -273,10 +273,8 @@ sealed abstract private[data] class OptionTInstances0 extends OptionTInstances1
   implicit def catsDataMonadErrorMonadForOptionT[F[_]](implicit F0: Monad[F]): MonadError[OptionT[F, ?], Unit] =
     new OptionTMonadErrorMonad[F] { implicit val F = F0 }
 
-  implicit def catsDataContravariantMonoidalForOptionT[F[_]](
-    implicit F0: ContravariantMonoidal[F]
-  ): ContravariantMonoidal[OptionT[F, ?]] =
-    new OptionTContravariantMonoidal[F] { implicit val F = F0 }
+  implicit def catsDataDecideableForOptionT[F[_]](implicit F0: Decideable[F]): Decideable[OptionT[F, ?]] =
+    new OptionTDecideable[F] { implicit val F = F0 }
 
   implicit def catsDataMonoidKForOptionT[F[_]](implicit F0: Monad[F]): MonoidK[OptionT[F, ?]] =
     new OptionTMonoidK[F] { implicit val F = F0 }
@@ -305,6 +303,12 @@ sealed abstract private[data] class OptionTInstances1 extends OptionTInstances2
 
   implicit def catsDataMonadErrorForOptionT[F[_], E](implicit F0: MonadError[F, E]): MonadError[OptionT[F, ?], E] =
     new OptionTMonadError[F, E] { implicit val F = F0 }
+
+  implicit def catsDataContravariantMonoidalForOptionT[F[_]](
+    implicit F0: ContravariantMonoidal[F]
+  ): ContravariantMonoidal[OptionT[F, ?]] =
+    new OptionTContravariantMonoidal[F] { implicit val F = F0 }
+
 }
 
 sealed abstract private[data] class OptionTInstances2 extends OptionTInstances3 {
@@ -382,6 +386,22 @@ private trait OptionTMonadError[F[_], E] extends MonadError[OptionT[F, ?], E] wi
     OptionT(F.handleErrorWith(fa.value)(f(_).value))
 }
 
+private trait OptionTDecideable[F[_]] extends Decideable[OptionT[F, ?]] with OptionTContravariantMonoidal[F] {
+  def F: Decideable[F]
+
+  def sum[A, B](fa: OptionT[F, A], fb: OptionT[F, B]): OptionT[F, Either[A, B]] =
+    OptionT(
+      F.decide(fa.value, fb.value)(
+        (e: Option[Either[A, B]]) =>
+          e match {
+            case Some(Right(b)) => Right(Option(b))
+            case Some(Left(a))  => Left(Option(a))
+            case None           => Left(None)
+        }
+      )
+    )
+}
+
 private trait OptionTContravariantMonoidal[F[_]] extends ContravariantMonoidal[OptionT[F, ?]] {
   def F: ContravariantMonoidal[F]