WIP: Selective

core/src/main/scala/cats/FlatMap.scala

@@ -20,7 +20,7 @@ import scala.annotation.implicitNotFound
  * Must obey the laws defined in cats.laws.FlatMapLaws.
  */
 @implicitNotFound("Could not find an instance of FlatMap for ${F}")
-@typeclass trait FlatMap[F[_]] extends Apply[F] {
+@typeclass trait FlatMap[F[_]] extends Select[F] {
   def flatMap[A, B](fa: F[A])(f: A => F[B]): F[B]
 
   /**

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/MonadError.scala

@@ -5,13 +5,7 @@ package cats
  *
  * This type class allows one to abstract over error-handling monads.
  */
-trait MonadError[F[_], E] extends ApplicativeError[F, E] with Monad[F] {
-
-  /**
-   * Turns a successful value into an error if it does not satisfy a given predicate.
-   */
-  def ensure[A](fa: F[A])(error: => E)(predicate: A => Boolean): F[A] =
-    flatMap(fa)(a => if (predicate(a)) pure(a) else raiseError(error))
+trait MonadError[F[_], E] extends SelectiveError[F, E] with Monad[F] {
 
   /**
    * Turns a successful value into an error specified by the `error` function if it does not satisfy a given predicate.

core/src/main/scala/cats/Select.scala

@@ -0,0 +1,13 @@
+package cats
+
+import simulacrum.{typeclass}
+import scala.annotation.implicitNotFound
+
+@implicitNotFound("Could not find an instance of Select for ${F}")
+@typeclass trait Select[F[_]] extends Apply[F] {
+  def select[A, B](fab: F[Either[A, B]])(ff: F[A => B]): F[B] =
+    map2(fab, ff) {
+      case (Left(a), f)  => f(a)
+      case (Right(b), f) => b
+    }
+}

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

@@ -0,0 +1,7 @@
+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] with Select[F]

core/src/main/scala/cats/SelectiveError.scala

@@ -0,0 +1,15 @@
+package cats
+
+import cats.syntax.either._
+
+trait SelectiveError[F[_], E] extends ApplicativeError[F, E] with Selective[F] {
+
+  /**
+   * Turns a successful value into an error if it does not satisfy a given predicate.
+   */
+  def ensure[A](fa: F[A])(error: => E)(predicate: A => Boolean): F[A] =
+    select(map(fa) { (a: A) =>
+      if (predicate(a)) Right(a)
+      else Either.leftUnit
+    })(raiseError(error))
+}

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,19 @@ 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]): SelectiveError[Validated[E, *], E] =
+    new ValidatedSelective[E] with SelectiveError[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 +956,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 +1042,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/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(())
 }