Update deprecations, method name

Author: Jacob Barber

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

@@ -18,42 +18,43 @@ trait Apply[F[_]] extends Functor[F] with Semigroupal[F] with ApplyArityFunction
   def ap[A, B](ff: F[A => B])(fa: F[A]): F[B]
 
   /** Compose two actions, discarding any value produced by the first. */
-  def apR[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)
 
   /** Compose two actions, discarding any value produced by the second. */
-  def apL[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)
 
   override def product[A, B](fa: F[A], fb: F[B]): F[(A, B)] =
-    ap(map(fa)(a => (b: B) => (a, b)))(fb)
+    map2(fa, fb)((_, _))
 
   /** Alias for [[ap]]. */
   @inline final def <*>[A, B](ff: F[A => B])(fa: F[A]): F[B] =
     ap(ff)(fa)
 
-  /** Alias for [[apR]]. */
+  /** Alias for [[productR]]. */
   @inline final def *>[A, B](fa: F[A])(fb: F[B]): F[B] =
-    apR(fa)(fb)
+    productR(fa)(fb)
 
-  /** Alias for [[apL]]. */
+  /** Alias for [[productL]]. */
   @inline final def <*[A, B](fa: F[A])(fb: F[B]): F[A] =
-    apL(fa)(fb)
+    productL(fa)(fb)
 
-  /** Alias for [[apR]]. */
-  @deprecated("Use *> or apR instead.", "1.0.0")
+  /** 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] =
-    apR(fa)(fb)
+    productR(fa)(fb)
 
-  /** Alias for [[apL]]. */
-  @deprecated("Use <* or apL instead.", "1.0.0")
+  /** 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] =
-    apL(fa)(fb)
+    productL(fa)(fb)
 
   /**
    * ap2 is a binary version of ap, defined in terms of ap.
    */
   def ap2[A, B, Z](ff: F[(A, B) => Z])(fa: F[A], fb: F[B]): F[Z] =
+
     map(product(fa, product(fb, ff))) { case (a, (b, f)) => f(a, b) }
 
   /**
@@ -62,7 +63,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) }
+    ap(map(fa)(a => (b: B) => f(a, b)))(fb)
 
   /**
    * Similar to [[map2]] but uses [[Eval]] to allow for laziness in the `F[B]`

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

@@ -44,28 +44,28 @@ import simulacrum.noop
 
   /**
    * Sequentially compose two actions, discarding any value produced by the first. This variant of
-   * [[apR]] 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.apREval(Eval.later(fb))
+   * scala> fa.productREval(Eval.later(fb))
    * res0: Option[String] = Some(foo)
    * }}}
    */
-  def apREval[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")
-  @noop def followedByEval[A, B](fa: F[A])(fb: Eval[F[B]]): F[B] = apREval(fa)(fb)
+  @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
-   * [[apL]] 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:
    *
    * {{{
@@ -74,18 +74,18 @@ import simulacrum.noop
    * scala> var count = 0
    * scala> val fa: Option[Int] = Some(3)
    * scala> def fb: Option[Unit] = Some(count += 1)
-   * scala> fa.apLEval(Eval.later(fb))
+   * scala> fa.productLEval(Eval.later(fb))
    * res0: Option[Int] = Some(3)
    * scala> assert(count == 1)
-   * scala> none[Int].apLEval(Eval.later(fb))
+   * scala> none[Int].productLEval(Eval.later(fb))
    * res1: Option[Int] = None
    * scala> assert(count == 1)
    * }}}
    */
-  def apLEval[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")
-  @noop def forEffectEval[A, B](fa: F[A])(fb: Eval[F[B]]): F[A] = apLEval(fa)(fb)
+  @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,25 +29,25 @@ trait NonEmptyParallel[M[_], F[_]] extends Serializable {
 
 
   /**
-    * Like `Apply[F].apR`, but uses the apply instance
+    * Like [[Apply.productR]], but uses the apply instance
     * corresponding to the Parallel instance instead.
     */
-  def parApR[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")
-  @inline def parFollowedBy[A, B](ma: M[A])(mb: M[B]): M[B] = parApR(ma)(mb)
+  @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].apL`, but uses the apply instance
+    * Like [[Apply.productL]], but uses the apply instance
     * corresponding to the Parallel instance instead.
     */
-  def parApL[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")
-  @inline def parForEffect[A, B](ma: M[A])(mb: M[B]): M[A] = parApL(ma)(mb)
+  @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 apR[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 apL[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

@@ -15,13 +15,13 @@ trait ApplySyntax extends TupleSemigroupalSyntax {
 }
 
 final class ApplyOps[F[_], A](val fa: F[A]) extends AnyVal {
-  /** Alias for [[Apply.apR]]. */
-  @deprecated("Use *> or apR instead.", "1.0.0")
+  /** 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.apR(fa)(fb)
+    F.productR(fa)(fb)
 
-  /** Alias for [[Apply.apL]]. */
-  @deprecated("Use <* or apL instead.", "1.0.0")
+  /** 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.apL(fa)(fb)
+    F.productL(fa)(fb)
 }

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

@@ -33,16 +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.apL(fa)(fb)
+  def <<[B](fb: F[B])(implicit F: FlatMap[F]): F[A] = F.productL(fa)(fb)
 
 
-  @deprecated("Use apREval instead.", "1.0.0")
+  @deprecated("Use productREval instead.", "1.0.0-RC2")
   def followedByEval[B](fb: Eval[F[B]])(implicit F: FlatMap[F]): F[B] =
-    F.apREval(fa)(fb)
+    F.productREval(fa)(fb)
 
-  @deprecated("Use apLEval instead.", "1.0.0")
+  @deprecated("Use productLEval instead.", "1.0.0-RC2")
   def forEffectEval[B](fb: Eval[F[B]])(implicit F: FlatMap[F]): F[A] =
-    F.apLEval(fa)(fb)
+    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.parApR(ma)(mb)
+    P.parProductR(ma)(mb)
 
   def <&[F[_], B](mb: M[B])(implicit P: Parallel[M, F]): M[A] =
-    P.parApL(ma)(mb)
+    P.parProductL(ma)(mb)
 
 }

laws/src/main/scala/cats/laws/ApplyLaws.scala

@@ -22,10 +22,10 @@ trait ApplyLaws[F[_]] extends FunctorLaws[F] with SemigroupalLaws[F] {
     F.map2(fa, fb)(f) <-> F.map2Eval(fa, Eval.now(fb))(f).value
 
   def apRConsistency[A, B](fa: F[A], fb: F[B]): IsEq[F[B]] =
-    F.apR(fa)(fb) <-> F.map2(fa, fb)((_, b) => b)
+    F.productR(fa)(fb) <-> F.map2(fa, fb)((_, b) => b)
 
   def apLConsistency[A, B](fa: F[A], fb: F[B]): IsEq[F[A]] =
-    F.apL(fa)(fb) <-> F.map2(fa, fb)((a, _) => a)
+    F.productL(fa)(fb) <-> F.map2(fa, fb)((a, _) => a)
 }
 
 object ApplyLaws {