Change forEffect/followedBy to productL/productR

build.sbt

@@ -341,6 +341,38 @@ def mimaSettings(moduleName: String) = Seq(
       exclude[ReversedMissingMethodProblem]("cats.MonadError.rethrow"),
       exclude[ReversedMissingMethodProblem]("cats.syntax.MonadErrorSyntax.catsSyntaxMonadErrorRethrow"),
       exclude[DirectMissingMethodProblem]("cats.data.CokleisliArrow.id"),
+      exclude[IncompatibleResultTypeProblem]("cats.data.CokleisliArrow.id"),  
+      exclude[DirectMissingMethodProblem]("cats.Apply#Ops.followedBy"),
+      exclude[DirectMissingMethodProblem]("cats.Apply#Ops.forEffect"),
+      exclude[ReversedMissingMethodProblem]("cats.Apply#Ops.<*>"),
+      exclude[ReversedMissingMethodProblem]("cats.Apply#Ops.productR"),
+      exclude[ReversedMissingMethodProblem]("cats.Apply#Ops.productL"),
+      exclude[ReversedMissingMethodProblem]("cats.Apply.<*>"),
+      exclude[ReversedMissingMethodProblem]("cats.Apply.productR"),
+      exclude[ReversedMissingMethodProblem]("cats.Apply.productL"),
+      exclude[ReversedMissingMethodProblem]("cats.FlatMap.productREval"),
+      exclude[ReversedMissingMethodProblem]("cats.FlatMap.productLEval"),
+      exclude[DirectMissingMethodProblem]("cats.FlatMap#Ops.forEffectEval"),
+      exclude[DirectMissingMethodProblem]("cats.FlatMap#Ops.followedByEval"),
+      exclude[ReversedMissingMethodProblem]("cats.FlatMap#Ops.productREval"),
+      exclude[ReversedMissingMethodProblem]("cats.FlatMap#Ops.productLEval"),
+      exclude[ReversedMissingMethodProblem]("cats.NonEmptyParallel.parProductR"),
+      exclude[ReversedMissingMethodProblem]("cats.NonEmptyParallel.parProductL"),
+      exclude[ReversedMissingMethodProblem]("cats.syntax.ApplySyntax.catsSyntaxApplyOps"),
+      exclude[FinalMethodProblem]("cats.data.IndexedStateTMonad.followedBy"),
+      exclude[FinalMethodProblem]("cats.data.IndexedStateTMonad.forEffect"),
+      exclude[FinalMethodProblem]("cats.data.RWSTMonad.followedBy"),
+      exclude[FinalMethodProblem]("cats.data.RWSTMonad.forEffect"),
+      exclude[FinalMethodProblem]("cats.data.CokleisliMonad.followedBy"),
+      exclude[FinalMethodProblem]("cats.data.CokleisliMonad.forEffect"),
+      exclude[FinalMethodProblem]("cats.data.NestedApplicativeError.followedBy"),
+      exclude[FinalMethodProblem]("cats.data.NestedApplicativeError.forEffect"),
+      exclude[FinalMethodProblem]("cats.data.ValidatedApplicative.followedBy"),
+      exclude[FinalMethodProblem]("cats.data.ValidatedApplicative.forEffect"),
+      exclude[FinalMethodProblem]("cats.data.RWSTAlternative.followedBy"),
+      exclude[FinalMethodProblem]("cats.data.RWSTAlternative.forEffect"),
+      exclude[IncompatibleMethTypeProblem]("cats.instances.FlatMapTuple2.followedBy"),
+      exclude[IncompatibleMethTypeProblem]("cats.instances.FlatMapTuple2.forEffect"),
       exclude[IncompatibleResultTypeProblem]("cats.data.CokleisliArrow.id"),
       exclude[UpdateForwarderBodyProblem]("cats.instances.Tuple2Instances1.catsStdMonadForTuple2"),
       exclude[ReversedMissingMethodProblem]("cats.instances.Tuple2Instances1.catsStdCommutativeMonadForTuple2"),

core/src/main/scala/cats/Apply.scala

@@ -1,6 +1,7 @@
 package cats
 
 import simulacrum.typeclass
+import simulacrum.noop
 
 /**
  * Weaker version of Applicative[F]; has apply but not pure.
@@ -16,24 +17,38 @@ trait Apply[F[_]] extends Functor[F] with Semigroupal[F] with ApplyArityFunction
    */
   def ap[A, B](ff: F[A => B])(fa: F[A]): F[B]
 
-  override def product[A, B](fa: F[A], fb: F[B]): F[(A, B)] =
-    ap(map(fa)(a => (b: B) => (a, b)))(fb)
-
   /** Compose two actions, discarding any value produced by the first. */
-  def followedBy[A, B](fa: F[A])(fb: F[B]): F[B] =
+  def productR[A, B](fa: F[A])(fb: F[B]): F[B] =
     map2(fa, fb)((_, b) => b)
 
-  /** Alias for [[followedBy]]. */
-  @inline final def *>[A, B](fa: F[A])(fb: F[B]): F[B] =
-    followedBy(fa)(fb)
-
   /** Compose two actions, discarding any value produced by the second. */
-  def forEffect[A, B](fa: F[A])(fb: F[B]): F[A] =
+  def productL[A, B](fa: F[A])(fb: F[B]): F[A] =
     map2(fa, fb)((a, _) => a)
 
-  /** Alias for [[forEffect]]. */
+  override def product[A, B](fa: F[A], fb: F[B]): F[(A, B)] =
+    ap(map(fa)(a => (b: B) => (a, b)))(fb)
+
+  /** Alias for [[ap]]. */
+  @inline final def <*>[A, B](ff: F[A => B])(fa: F[A]): F[B] =
+    ap(ff)(fa)
+
+  /** Alias for [[productR]]. */
+  @inline final def *>[A, B](fa: F[A])(fb: F[B]): F[B] =
+    productR(fa)(fb)
+
+  /** Alias for [[productL]]. */
   @inline final def <*[A, B](fa: F[A])(fb: F[B]): F[A] =
-    forEffect(fa)(fb)
+    productL(fa)(fb)
+
+  /** Alias for [[productR]]. */
+  @deprecated("Use *> or apR instead.", "1.0.0-RC2")
+  @noop @inline final def followedBy[A, B](fa: F[A])(fb: F[B]): F[B] =
+    productR(fa)(fb)
+
+  /** Alias for [[productL]]. */
+  @deprecated("Use <* or apL instead.", "1.0.0-RC2")
+  @noop @inline final def forEffect[A, B](fa: F[A])(fb: F[B]): F[A] =
+    productL(fa)(fb)
 
   /**
    * ap2 is a binary version of ap, defined in terms of ap.
@@ -47,7 +62,7 @@ trait Apply[F[_]] extends Functor[F] with Semigroupal[F] with ApplyArityFunction
    * map2 can be seen as a binary version of [[cats.Functor]]#map.
    */
   def map2[A, B, Z](fa: F[A], fb: F[B])(f: (A, B) => Z): F[Z] =
-    map(product(fa, fb)) { case (a, b) => f(a, b) }
+    map(product(fa, fb))(f.tupled)
 
   /**
    * Similar to [[map2]] but uses [[Eval]] to allow for laziness in the `F[B]`

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

@@ -1,6 +1,7 @@
 package cats
 
 import simulacrum.typeclass
+import simulacrum.noop
 
 /**
  * FlatMap type class gives us flatMap, which allows us to have a value
@@ -43,25 +44,28 @@ import simulacrum.typeclass
 
   /**
    * Sequentially compose two actions, discarding any value produced by the first. This variant of
-   * [[followedBy]] also lets you define the evaluation strategy of the second action. For instance
+   * [[productR]] also lets you define the evaluation strategy of the second action. For instance
    * you can evaluate it only ''after'' the first action has finished:
    *
    * {{{
    * scala> import cats.Eval
    * scala> import cats.implicits._
    * scala> val fa: Option[Int] = Some(3)
    * scala> def fb: Option[String] = Some("foo")
-   * scala> fa.followedByEval(Eval.later(fb))
+   * scala> fa.productREval(Eval.later(fb))
    * res0: Option[String] = Some(foo)
    * }}}
    */
-  def followedByEval[A, B](fa: F[A])(fb: Eval[F[B]]): F[B] = flatMap(fa)(_ => fb.value)
+  def productREval[A, B](fa: F[A])(fb: Eval[F[B]]): F[B] = flatMap(fa)(_ => fb.value)
+
+  @deprecated("Use apREval instead.", "1.0.0-RC2")
+  @noop def followedByEval[A, B](fa: F[A])(fb: Eval[F[B]]): F[B] = productREval(fa)(fb)
 
 
 
   /**
    * Sequentially compose two actions, discarding any value produced by the second. This variant of
-   * [[forEffect]] also lets you define the evaluation strategy of the second action. For instance
+   * [[productL]] also lets you define the evaluation strategy of the second action. For instance
    * you can evaluate it only ''after'' the first action has finished:
    *
    * {{{
@@ -70,15 +74,18 @@ import simulacrum.typeclass
    * scala> var count = 0
    * scala> val fa: Option[Int] = Some(3)
    * scala> def fb: Option[Unit] = Some(count += 1)
-   * scala> fa.forEffectEval(Eval.later(fb))
+   * scala> fa.productLEval(Eval.later(fb))
    * res0: Option[Int] = Some(3)
    * scala> assert(count == 1)
-   * scala> none[Int].forEffectEval(Eval.later(fb))
+   * scala> none[Int].productLEval(Eval.later(fb))
    * res1: Option[Int] = None
    * scala> assert(count == 1)
    * }}}
    */
-  def forEffectEval[A, B](fa: F[A])(fb: Eval[F[B]]): F[A] = flatMap(fa)(a => map(fb.value)(_ => a))
+  def productLEval[A, B](fa: F[A])(fb: Eval[F[B]]): F[A] = flatMap(fa)(a => map(fb.value)(_ => a))
+
+  @deprecated("Use apLEval instead.", "1.0.0-RC2")
+  @noop def forEffectEval[A, B](fa: F[A])(fb: Eval[F[B]]): F[A] = productLEval(fa)(fb)
 
   override def ap[A, B](ff: F[A => B])(fa: F[A]): F[B] =
     flatMap(ff)(f => map(fa)(f))

core/src/main/scala/cats/Parallel.scala

@@ -29,20 +29,26 @@ trait NonEmptyParallel[M[_], F[_]] extends Serializable {
 
 
   /**
-    * Like `Apply[F].followedBy`, but uses the apply instance
+    * Like [[Apply.productR]], but uses the apply instance
     * corresponding to the Parallel instance instead.
     */
-  def parFollowedBy[A, B](ma: M[A])(mb: M[B]): M[B] =
+  def parProductR[A, B](ma: M[A])(mb: M[B]): M[B] =
     Parallel.parMap2(ma, mb)((_, b) => b)(this)
 
+  @deprecated("Use parApR instead.", "1.0.0-RC2")
+  @inline def parFollowedBy[A, B](ma: M[A])(mb: M[B]): M[B] = parProductR(ma)(mb)
+
 
   /**
-    * Like `Apply[F].forEffect`, but uses the apply instance
+    * Like [[Apply.productL]], but uses the apply instance
     * corresponding to the Parallel instance instead.
     */
-  def parForEffect[A, B](ma: M[A])(mb: M[B]): M[A] =
+  def parProductL[A, B](ma: M[A])(mb: M[B]): M[A] =
     Parallel.parMap2(ma, mb)((a, _) => a)(this)
 
+  @deprecated("Use parApR instead.", "1.0.0-RC2")
+  @inline def parForEffect[A, B](ma: M[A])(mb: M[B]): M[A] = parProductL(ma)(mb)
+
 }
 
 /**

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

@@ -123,10 +123,10 @@ private[instances] class FlatMapTuple2[X](s: Semigroup[X]) extends FlatMap[(X, ?
     (x, xb._2)
   }
 
-  override def followedBy[A, B](a: (X, A))(b: (X, B)): (X, B) =
+  override def productR[A, B](a: (X, A))(b: (X, B)): (X, B) =
     (s.combine(a._1, b._1), b._2)
 
-  override def forEffect[A, B](a: (X, A))(b: (X, B)): (X, A) =
+  override def productL[A, B](a: (X, A))(b: (X, B)): (X, A) =
     (s.combine(a._1, b._1), a._2)
 
   override def mproduct[A, B](fa: (X, A))(f: A => (X, B)): (X, (A, B)) = {

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

@@ -9,4 +9,19 @@ trait ApplySyntax extends TupleSemigroupalSyntax {
       val self = fa
       val typeClassInstance = F
     }
+
+  implicit final def catsSyntaxApplyOps[F[_], A](fa: F[A]): ApplyOps[F, A] =
+    new ApplyOps(fa)
+}
+
+final class ApplyOps[F[_], A](val fa: F[A]) extends AnyVal {
+  /** Alias for [[Apply.productR]]. */
+  @deprecated("Use *> or apR instead.", "1.0.0-RC2")
+  @inline def followedBy[B](fb: F[B])(implicit F: Apply[F]): F[B] =
+    F.productR(fa)(fb)
+
+  /** Alias for [[Apply.productL]]. */
+  @deprecated("Use <* or apL instead.", "1.0.0-RC2")
+  @inline def forEffect[B](fb: F[B])(implicit F: Apply[F]): F[A] =
+    F.productL(fa)(fb)
 }

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

@@ -33,7 +33,16 @@ final class FlatMapOps[F[_], A](val fa: F[A]) extends AnyVal {
   def >>[B](fb: => F[B])(implicit F: FlatMap[F]): F[B] = F.flatMap(fa)(_ => fb)
 
   @deprecated("Use <* instead", "1.0.0-RC1")
-  def <<[B](fb: F[B])(implicit F: FlatMap[F]): F[A] = F.forEffect(fa)(fb)
+  def <<[B](fb: F[B])(implicit F: FlatMap[F]): F[A] = F.productL(fa)(fb)
+
+
+  @deprecated("Use productREval instead.", "1.0.0-RC2")
+  def followedByEval[B](fb: Eval[F[B]])(implicit F: FlatMap[F]): F[B] =
+    F.productREval(fa)(fb)
+
+  @deprecated("Use productLEval instead.", "1.0.0-RC2")
+  def forEffectEval[B](fb: Eval[F[B]])(implicit F: FlatMap[F]): F[A] =
+    F.productLEval(fa)(fb)
 }
 
 final class FlattenOps[F[_], A](val ffa: F[F[A]]) extends AnyVal {

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

@@ -32,9 +32,9 @@ final class ParallelSequenceOps[T[_], M[_], A](val tma: T[M[A]]) extends AnyVal
 final class ParallelApOps[M[_], A](val ma: M[A]) extends AnyVal {
 
   def &>[F[_], B](mb: M[B])(implicit P: Parallel[M, F]): M[B] =
-    P.parFollowedBy(ma)(mb)
+    P.parProductR(ma)(mb)
 
   def <&[F[_], B](mb: M[B])(implicit P: Parallel[M, F]): M[A] =
-    P.parForEffect(ma)(mb)
+    P.parProductL(ma)(mb)
 
 }