WIP: Selective

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

@@ -185,7 +185,6 @@ import scala.annotation.implicitNotFound
    */
   def whenA[A](cond: Boolean)(f: => F[A]): F[Unit] =
     if (cond) void(f) else unit
-
 }
 
 object Applicative {

core/src/main/scala/cats/Monad.scala

@@ -13,10 +13,16 @@ import scala.annotation.implicitNotFound
  * Must obey the laws defined in cats.laws.MonadLaws.
  */
 @implicitNotFound("Could not find an instance of Monad for ${F}")
-@typeclass trait Monad[F[_]] extends FlatMap[F] with Applicative[F] {
+@typeclass trait Monad[F[_]] extends FlatMap[F] with Selective[F] {
   override def map[A, B](fa: F[A])(f: A => B): F[B] =
     flatMap(fa)(a => pure(f(a)))
 
+  override def select[A, B](fab: F[Either[A, B]])(ff: F[A => B]): F[B] =
+    flatMap(fab) {
+      case Left(a)  => map(ff)(_(a))
+      case Right(b) => pure(b)
+    }
+
   /**
    * Execute an action repeatedly as long as the given `Boolean` expression
    * returns `true`. The condition is evaluated before the loop body.

core/src/main/scala/cats/Selective.scala

@@ -0,0 +1,28 @@
+package cats
+
+import simulacrum.{typeclass}
+import scala.annotation.implicitNotFound
+
+@implicitNotFound("Could not find an instance of Selective for ${F}")
+@typeclass trait Selective[F[_]] extends Applicative[F] {
+  def select[A, B](fab: F[Either[A, B]])(ff: F[A => B]): F[B]
+
+  def branch[A, B, C](fab: F[Either[A, B]])(fl: F[A => C])(fr: F[B => C]): F[C] = {
+    val lhs = {
+      val innerLhs: F[Either[A, Either[B, C]]] = map(fab)(_.map(Left(_)))
+      val innerRhs: F[A => Either[B, C]] = map(fl)(_.andThen(Right(_)))
+      select(innerLhs)(innerRhs)
+    }
+    select(lhs)(fr)
+  }
+
+  def ifS[A](x: F[Boolean])(t: F[A])(e: F[A]): F[A] = {
+    val condition: F[Either[Unit, Unit]] = map(x)(p => if (p) Left(()) else Right(()))
+    val left: F[Unit => A] = map(t)(Function.const)
+    val right: F[Unit => A] = map(e)(Function.const)
+    branch(condition)(left)(right)
+  }
+
+  def whenS[A](fbool: F[Boolean])(fa: F[Unit]): F[Unit] =
+    ifS(fbool)(fa)(unit)
+}

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

@@ -922,7 +922,7 @@ abstract private[data] class EitherTInstances extends EitherTInstances1 {
       implicit val monadEither: Monad[Either[E, *]] = cats.instances.either.catsStdInstancesForEither
 
       def applicative: Applicative[Nested[P.F, Validated[E, *], *]] =
-        cats.data.Nested.catsDataApplicativeForNested(P.applicative, Validated.catsDataApplicativeErrorForValidated)
+        cats.data.Nested.catsDataApplicativeForNested(P.applicative, Validated.catsDataSelectiveErrorForValidated)
 
       def monad: Monad[EitherT[M, E, *]] = cats.data.EitherT.catsDataMonadErrorForEitherT
 
@@ -983,7 +983,7 @@ abstract private[data] class EitherTInstances1 extends EitherTInstances2 {
     new Parallel[EitherT[M, E, *]] {
       type F[x] = Nested[M, Validated[E, *], x]
 
-      implicit val appValidated: Applicative[Validated[E, *]] = Validated.catsDataApplicativeErrorForValidated
+      implicit val appValidated: Applicative[Validated[E, *]] = Validated.catsDataSelectiveErrorForValidated
       implicit val monadEither: Monad[Either[E, *]] = cats.instances.either.catsStdInstancesForEither
 
       def applicative: Applicative[Nested[M, Validated[E, *], *]] =

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

@@ -931,16 +931,21 @@ sealed abstract private[data] class ValidatedInstances extends ValidatedInstance
         fab.leftMap(f)
     }
 
-  implicit def catsDataApplicativeErrorForValidated[E](implicit E: Semigroup[E]): ApplicativeError[Validated[E, *], E] =
-    new ValidatedApplicative[E] with ApplicativeError[Validated[E, *], E] {
-
+  implicit def catsDataSelectiveErrorForValidated[E](implicit
+    E: Semigroup[E]
+  ): Selective[Validated[E, *]] with ApplicativeError[Validated[E, *], E] =
+    new ValidatedSelective[E] with ApplicativeError[Validated[E, *], E] {
       def handleErrorWith[A](fa: Validated[E, A])(f: E => Validated[E, A]): Validated[E, A] =
         fa match {
           case Validated.Invalid(e)   => f(e)
           case v @ Validated.Valid(_) => v
         }
       def raiseError[A](e: E): Validated[E, A] = Validated.Invalid(e)
     }
+
+  @deprecated("Use catsDataSelectiveErrorForValidated", "2.4.0")
+  def catsDataApplicativeErrorForValidated[E](implicit E: Semigroup[E]): ApplicativeError[Validated[E, *], E] =
+    catsDataSelectiveErrorForValidated
 }
 
 sealed abstract private[data] class ValidatedInstances1 extends ValidatedInstances2 {
@@ -953,9 +958,13 @@ sealed abstract private[data] class ValidatedInstances1 extends ValidatedInstanc
       def combine(x: Validated[A, B], y: Validated[A, B]): Validated[A, B] = x.combine(y)
     }
 
-  implicit def catsDataCommutativeApplicativeForValidated[E: CommutativeSemigroup]
-    : CommutativeApplicative[Validated[E, *]] =
-    new ValidatedApplicative[E] with CommutativeApplicative[Validated[E, *]]
+  implicit def catsDataCommutativeSelectiveForValidated[E: CommutativeSemigroup]
+    : Selective[Validated[E, *]] with CommutativeApplicative[Validated[E, *]] =
+    new ValidatedSelective[E] with CommutativeApplicative[Validated[E, *]]
+
+  @deprecated("Use catsDataCommutativeSelectiveForValidated", "2.4.0")
+  def catsDataCommutativeApplicativeForValidated[E: CommutativeSemigroup]: CommutativeApplicative[Validated[E, *]] =
+    catsDataCommutativeApplicativeForValidated
 
   implicit def catsDataPartialOrderForValidated[A: PartialOrder, B: PartialOrder]: PartialOrder[Validated[A, B]] =
     new PartialOrder[Validated[A, B]] {
@@ -1035,6 +1044,15 @@ sealed abstract private[data] class ValidatedInstances2 {
   // scalastyle:off method.length
 }
 
+private[data] class ValidatedSelective[E: Semigroup] extends ValidatedApplicative[E] with Selective[Validated[E, *]] {
+  override def select[A, B](fab: Validated[E, Either[A, B]])(ff: Validated[E, A => B]): Validated[E, B] =
+    fab match {
+      case Valid(Left(a))  => ff.map(_(a))
+      case Valid(Right(b)) => Valid(b)
+      case i @ Invalid(_)  => i
+    }
+}
+
 private[data] class ValidatedApplicative[E: Semigroup] extends CommutativeApplicative[Validated[E, *]] {
   override def map[A, B](fa: Validated[E, A])(f: A => B): Validated[E, B] =
     fa.map(f)

core/src/main/scala/cats/instances/either.scala

@@ -207,7 +207,7 @@ trait EitherInstances extends cats.kernel.instances.EitherInstances {
     new Parallel[Either[E, *]] {
       type F[x] = Validated[E, x]
 
-      def applicative: Applicative[Validated[E, *]] = Validated.catsDataApplicativeErrorForValidated
+      def applicative: Applicative[Validated[E, *]] = Validated.catsDataSelectiveErrorForValidated
       def monad: Monad[Either[E, *]] = cats.instances.either.catsStdInstancesForEither
 
       def sequential: Validated[E, *] ~> Either[E, *] =

core/src/main/scala/cats/syntax/all.scala

@@ -51,6 +51,7 @@ trait AllSyntax
     with PartialOrderSyntax
     with ProfunctorSyntax
     with ReducibleSyntax
+    with SelectiveSyntax
     with SemigroupSyntax
     with SemigroupKSyntax
     with ShowSyntax

core/src/main/scala/cats/syntax/either.scala

@@ -395,6 +395,11 @@ final class EitherObjectOps(private val either: Either.type) extends AnyVal { //
    * Cached value of `Right(())` to avoid allocations for a common case.
    */
   def unit[A]: Either[A, Unit] = EitherUtil.unit
+
+  /**
+   * Cached value of `Left(())` to avoid allocations for a common case.
+   */
+  def leftUnit[B]: Either[Unit, B] = EitherUtil.leftUnit
 }
 
 final class LeftOps[A, B](private val left: Left[A, B]) extends AnyVal {
@@ -509,4 +514,5 @@ private[cats] object EitherUtil {
     left.asInstanceOf[Either[A, C]]
 
   private[cats] val unit = Right(())
+  private[cats] val leftUnit = Left(())
 }

core/src/main/scala/cats/syntax/selective.scala

@@ -0,0 +1,24 @@
+package cats
+package syntax
+
+trait SelectiveSyntax {
+  implicit final def catsSyntaxSelective[F[_], A, B](fab: F[Either[A, B]]): SelectiveOps[F, A, B] =
+    new SelectiveOps(fab)
+  implicit final def catsSyntaxIfS[F[_]](fBool: F[Boolean]): IfSOps[F] =
+    new IfSOps(fBool)
+  implicit final def catsSyntaxWhenS[F[_]](fBool: F[Boolean]): WhenSOps[F] =
+    new WhenSOps(fBool)
+}
+
+final class SelectiveOps[F[_], A, B](private val fab: F[Either[A, B]]) extends AnyVal {
+  def select(ff: F[A => B])(implicit F: Selective[F]): F[B] = F.select(fab)(ff)
+  def branch[C](l: F[A => C])(r: F[B => C])(implicit F: Selective[F]): F[C] = F.branch(fab)(l)(r)
+}
+
+final class IfSOps[F[_]](private val fBool: F[Boolean]) extends AnyVal {
+  def ifS[A](ifTrue: => F[A])(ifFalse: => F[A])(implicit F: Selective[F]): F[A] = F.ifS(fBool)(ifTrue)(ifFalse)
+}
+
+final class WhenSOps[F[_]](private val fBool: F[Boolean]) extends AnyVal {
+  def whenS[A](fa: F[Unit])(implicit F: Selective[F]): F[Unit] = F.whenS(fBool)(fa)
+}

laws/src/main/scala/cats/laws/MonadLaws.scala

@@ -7,7 +7,7 @@ import cats.implicits._
 /**
  * Laws that must be obeyed by any `Monad`.
  */
-trait MonadLaws[F[_]] extends ApplicativeLaws[F] with FlatMapLaws[F] {
+trait MonadLaws[F[_]] extends SelectiveLaws[F] with FlatMapLaws[F] {
   implicit override def F: Monad[F]
 
   def monadLeftIdentity[A, B](a: A, f: A => F[B]): IsEq[F[B]] =
@@ -41,6 +41,15 @@ trait MonadLaws[F[_]] extends ApplicativeLaws[F] with FlatMapLaws[F] {
     val res = F.tailRecM(0)(i => F.pure(if (i < n) Either.left(i + 1) else Either.right(i)))
     res <-> F.pure(n)
   }
+
+  def selectRigidity[A, B](fab: F[Either[A, B]], ff: F[A => B]): IsEq[F[B]] = {
+    def selectM[G[_]: Monad](gab: G[Either[A, B]])(gf: G[A => B]) =
+      gab.flatMap {
+        case Left(a)  => gf.map(_(a))
+        case Right(b) => b.pure[G]
+      }
+    fab.select(ff) <-> selectM(fab)(ff)
+  }
 }
 
 object MonadLaws {

laws/src/main/scala/cats/laws/SelectiveLaws.scala

@@ -0,0 +1,48 @@
+package cats
+package laws
+
+import cats.syntax.all._
+
+/**
+ * Laws that must be obeyed by any `Selective`.
+ */
+trait SelectiveLaws[F[_]] extends ApplicativeLaws[F] {
+  implicit override def F: Selective[F]
+
+  def selectiveIdentity[A, B](faa: F[Either[A, A]]): IsEq[F[A]] =
+    faa.select(F.pure(identity)) <-> faa.map(_.merge)
+
+  def selectiveDistributivity[A, B](ab: Either[A, B], ff1: F[A => B], ff2: F[A => B]): IsEq[F[B]] =
+    F.pure(ab).select(ff1 *> ff2) <-> F.pure(ab).select(ff1) *> F.pure(ab).select(ff2)
+
+  // TODO associativity
+
+  def selectiveBranchConsistency[A, B, C](fab: F[Either[A, B]], fl: F[A => C], fr: F[B => C]): IsEq[F[C]] = {
+    fab.branch(fl)(fr) <-> {
+      val lhs = {
+        val innerLhs: F[Either[A, Either[B, C]]] = F.map(fab)(_.map(Left(_)))
+        val innerRhs: F[A => Either[B, C]] = F.map(fl)(_.andThen(Right(_)))
+        F.select(innerLhs)(innerRhs)
+      }
+      F.select(lhs)(fr)
+    }
+  }
+
+  def selectiveIfSConsistency[A](fb: F[Boolean], ft: F[A], ff: F[A]): IsEq[F[A]] = {
+    fb.ifS(ft)(ff) <-> {
+      val condition: F[Either[Unit, Unit]] = F.map(fb)(p => if (p) Left(()) else Right(()))
+      val left: F[Unit => A] = F.map(ft)(Function.const)
+      val right: F[Unit => A] = F.map(ff)(Function.const)
+      F.branch(condition)(left)(right)
+    }
+  }
+
+  def selectiveWhenSConsistency[A](fb: F[Boolean], fa: F[Unit]): IsEq[F[Unit]] = {
+    fb.whenS(fa) <-> F.ifS(fb)(fa)(F.unit)
+  }
+}
+
+object SelectiveLaws {
+  def apply[F[_]](implicit ev: Selective[F]): SelectiveLaws[F] =
+    new SelectiveLaws[F] { def F: Selective[F] = ev }
+}

laws/src/main/scala/cats/laws/discipline/MonadTests.scala

@@ -7,7 +7,7 @@ import cats.platform.Platform
 import org.scalacheck.{Arbitrary, Cogen, Prop}
 import Prop._
 
-trait MonadTests[F[_]] extends ApplicativeTests[F] with FlatMapTests[F] {
+trait MonadTests[F[_]] extends SelectiveTests[F] with FlatMapTests[F] {
   def laws: MonadLaws[F]
 
   def monad[A: Arbitrary: Eq, B: Arbitrary: Eq, C: Arbitrary: Eq](implicit
@@ -29,7 +29,7 @@ trait MonadTests[F[_]] extends ApplicativeTests[F] with FlatMapTests[F] {
     new RuleSet {
       def name: String = "monad"
       def bases: Seq[(String, RuleSet)] = Nil
-      def parents: Seq[RuleSet] = Seq(applicative[A, B, C], flatMap[A, B, C])
+      def parents: Seq[RuleSet] = Seq(selective[A, B, C], flatMap[A, B, C])
       def props: Seq[(String, Prop)] =
         Seq(
           "monad left identity" -> forAll(laws.monadLeftIdentity[A, B] _),
@@ -58,7 +58,7 @@ trait MonadTests[F[_]] extends ApplicativeTests[F] with FlatMapTests[F] {
     new RuleSet {
       def name: String = "monad (stack-unsafe)"
       def bases: Seq[(String, RuleSet)] = Nil
-      def parents: Seq[RuleSet] = Seq(applicative[A, B, C], flatMap[A, B, C])
+      def parents: Seq[RuleSet] = Seq(selective[A, B, C], flatMap[A, B, C])
       def props: Seq[(String, Prop)] =
         Seq(
           "monad left identity" -> forAll(laws.monadLeftIdentity[A, B] _),

laws/src/main/scala/cats/laws/discipline/SelectiveTests.scala

@@ -0,0 +1,80 @@
+package cats
+package laws
+package discipline
+
+import cats.laws.discipline.SemigroupalTests.Isomorphisms
+import cats.syntax.all._
+import org.scalacheck.{Arbitrary, Cogen, Gen, Prop}
+import Prop._
+
+trait SelectiveTests[F[_]] extends ApplicativeTests[F] {
+  def laws: SelectiveLaws[F]
+
+  def selective[A: Arbitrary: Eq, B: Arbitrary: Eq, C: Arbitrary: Eq](implicit
+    ArbFA: Arbitrary[F[A]],
+    ArbFB: Arbitrary[F[B]],
+    ArbFC: Arbitrary[F[C]],
+    ArbFAtoB: Arbitrary[F[A => B]],
+    ArbFBtoC: Arbitrary[F[B => C]],
+    CogenA: Cogen[A],
+    CogenB: Cogen[B],
+    CogenC: Cogen[C],
+    EqFA: Eq[F[A]],
+    EqFB: Eq[F[B]],
+    EqFC: Eq[F[C]],
+    EqFABC: Eq[F[(A, B, C)]],
+    EqFInt: Eq[F[Int]],
+    iso: Isomorphisms[F]
+  ): RuleSet = {
+    implicit val ArbFBool: Arbitrary[F[Boolean]] = arbFB[A, Boolean]
+    implicit val ArbFUnit: Arbitrary[F[Unit]] = arbFB[A, Unit]
+    new RuleSet {
+      def name: String = "selective"
+      def bases: Seq[(String, RuleSet)] = Nil
+      def parents: Seq[RuleSet] = Seq(applicative[A, B, C])
+      def props: Seq[(String, Prop)] =
+        Seq(
+          "selective identity" -> forAll(laws.selectiveIdentity[A, B] _),
+          "selective branch consistency" -> forAll(laws.selectiveBranchConsistency[A, B, C] _),
+          "selective ifS consistency" -> forAll(laws.selectiveIfSConsistency[A] _),
+          "selective whenS consistency" -> forAll(laws.selectiveWhenSConsistency[A] _)
+        )
+    }
+  }
+
+  implicit private def arbFAB[A, B](implicit
+    arbFA: Arbitrary[F[A]],
+    arbFB: Arbitrary[F[B]]
+  ): Arbitrary[F[Either[A, B]]] = {
+    Arbitrary(
+      Gen.oneOf(arbFA.arbitrary.map(fa => laws.F.map(fa)(_.asLeft[B])),
+                arbFB.arbitrary.map(fb => laws.F.map(fb)(_.asRight[A]))
+      )
+    )
+  }
+
+  private def arbFB[A, B](implicit arbFA: Arbitrary[F[A]], arbB: Arbitrary[B]): Arbitrary[F[B]] =
+    Arbitrary(for {
+      fa <- arbFA.arbitrary
+      b <- arbB.arbitrary
+    } yield laws.F.as(fa, b))
+
+  implicit private def arbFAtoC[A, B, C](implicit
+    arbFAtoB: Arbitrary[F[A => B]],
+    arbFBtoC: Arbitrary[F[B => C]]
+  ): Arbitrary[F[A => C]] =
+    Arbitrary(for {
+      fAToB <- arbFAtoB.arbitrary
+      fBToC <- arbFBtoC.arbitrary
+    } yield laws.F.map2(fAToB, fBToC)(_ andThen _))
+
+  implicit private def eqFUnit(implicit eqFInt: Eq[F[Int]]): Eq[F[Unit]] =
+    Eq.by(laws.F.map(_)(_ => 0))
+}
+
+object SelectiveTests {
+  def apply[F[_]: Selective]: SelectiveTests[F] =
+    new SelectiveTests[F] {
+      def laws: SelectiveLaws[F] = SelectiveLaws[F]
+    }
+}