Fix unnecessary syntax allocation

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

@@ -111,6 +111,7 @@ trait AllSyntaxBinCompat3 extends UnorderedFoldableSyntax with Function1Syntax
 trait AllSyntaxBinCompat4
     extends TraverseFilterSyntaxBinCompat0
     with ApplySyntaxBinCompat0
+    with ApplySyntaxBinCompat1
     with ParallelApplySyntax
     with FoldableSyntaxBinCompat0
     with ReducibleSyntaxBinCompat0

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

@@ -23,7 +23,8 @@ package cats
 package syntax
 
 trait ApplySyntax extends TupleSemigroupalSyntax {
-  implicit final def catsSyntaxApply[F[_], A](fa: F[A])(implicit F: Apply[F]): Apply.Ops[F, A] =
+  @deprecated("Use `ApplySyntaxBinCompat1`", "2.10.0")
+  final def catsSyntaxApply[F[_], A](fa: F[A], F: Apply[F]): Apply.Ops[F, A] =
     new Apply.Ops[F, A] {
       type TypeClassType = Apply[F]
 
@@ -40,6 +41,205 @@ private[syntax] trait ApplySyntaxBinCompat0 {
     new IfApplyOps[F](fa)
 }
 
+private[syntax] trait ApplySyntaxBinCompat1 {
+  implicit final def catsSyntaxApplyFABOps[F[_], A, B](fab: F[A => B]): ApplyFABOps[F, A, B] =
+    new ApplyFABOps[F, A, B](fab)
+
+  implicit final def catsSyntaxApply2Ops[F[_], A, B, C](ff: F[(A, B) => C]): Apply2Ops[F, A, B, C] =
+    new Apply2Ops[F, A, B, C](ff)
+
+  implicit final def catsSyntaxApplyOps2[F[_], A](fa: F[A]): ApplyOps2[F, A] =
+    new ApplyOps2[F, A](fa)
+}
+
+final class ApplyFABOps[F[_], A, B](private val fab: F[A => B]) extends AnyVal {
+
+  /**
+   * @see [[Apply.ap]].
+   * 
+   * Example:
+   * {{{
+   * scala> import cats.syntax.all._
+   *
+   * scala> val someF: Option[Int => Long] = Some(_.toLong + 1L)
+   * scala> val noneF: Option[Int => Long] = None
+   * scala> val someInt: Option[Int] = Some(3)
+   * scala> val noneInt: Option[Int] = None
+   *
+   * scala> someF.ap(someInt)
+   * res0: Option[Long] = Some(4)
+   *
+   * scala> noneF.ap(someInt)
+   * res1: Option[Long] = None
+   *
+   * scala> someF.ap(noneInt)
+   * res2: Option[Long] = None
+   *
+   * scala> noneF.ap(noneInt)
+   * res3: Option[Long] = None
+   * }}}
+   */
+  def ap(fa: F[A])(implicit F: Apply[F]): F[B] = F.ap(fab)(fa)
+
+  /**
+   * Alias for [[ap]].
+   */
+  def <*>(fa: F[A])(implicit F: Apply[F]): F[B] = F.<*>[A, B](fab)(fa)
+}
+
+final class Apply2Ops[F[_], A, B, C](private val ff: F[(A, B) => C]) extends AnyVal {
+
+  /**
+   * @see [[Apply.ap2]].
+   * 
+   * Example:
+   * {{{
+   * scala> import cats.syntax.all._
+   *
+   * scala> val someF: Option[(Int, Int) => Long] = Some((a, b) => (a + b).toLong)
+   * scala> val noneF: Option[(Int, Int) => Long] = None
+   * scala> val someInt1: Option[Int] = Some(3)
+   * scala> val someInt2: Option[Int] = Some(2)
+   * scala> val noneInt: Option[Int] = None
+   *
+   * scala> someF.ap2(someInt1, someInt2)
+   * res0: Option[Long] = Some(5)
+   *
+   * scala> noneF.ap2(someInt1, someInt2)
+   * res1: Option[Long] = None
+   *
+   * scala> someF.ap2(noneInt, noneInt)
+   * res2: Option[Long] = None
+   *
+   * scala> noneF.ap2(noneInt, noneInt)
+   * res3: Option[Long] = None
+   * }}}
+   * 
+   */
+  def ap2(fa: F[A], fb: F[B])(implicit F: Apply[F]): F[C] = F.ap2(ff)(fa, fb)
+}
+
+final class ApplyOps2[F[_], A](private val fa: F[A]) extends AnyVal {
+
+  /**
+   * @see [[Apply.productR]].
+   * 
+   * Example:
+   * {{{
+   * scala> import cats.syntax.all._
+   * scala> import cats.data.Validated
+   * scala> import Validated.{Valid, Invalid}
+   *
+   * scala> type ErrOr[A] = Validated[String, A]
+   *
+   * scala> val validInt: ErrOr[Int] = Valid(3)
+   * scala> val validBool: ErrOr[Boolean] = Valid(true)
+   * scala> val invalidInt: ErrOr[Int] = Invalid("Invalid int.")
+   * scala> val invalidBool: ErrOr[Boolean] = Invalid("Invalid boolean.")
+   *
+   * scala> validInt.productR(validBool)
+   * res0: ErrOr[Boolean] = Valid(true)
+   *
+   * scala> invalidInt.productR(validBool)
+   * res1: ErrOr[Boolean] = Invalid(Invalid int.)
+   *
+   * scala> validInt.productR(invalidBool)
+   * res2: ErrOr[Boolean] = Invalid(Invalid boolean.)
+   *
+   * scala> invalidInt.productR(invalidBool)
+   * res3: ErrOr[Boolean] = Invalid(Invalid int.Invalid boolean.)
+   * }}}    
+   */
+  def productR[B](fb: F[B])(implicit F: Apply[F]): F[B] = F.productR(fa)(fb)
+
+  /**
+   * @see [[Apply.productL]].
+   * 
+   * Example:
+   * {{{
+   * scala> import cats.syntax.all._
+   * scala> import cats.data.Validated
+   * scala> import Validated.{Valid, Invalid}
+   *
+   * scala> type ErrOr[A] = Validated[String, A]
+   *
+   * scala> val validInt: ErrOr[Int] = Valid(3)
+   * scala> val validBool: ErrOr[Boolean] = Valid(true)
+   * scala> val invalidInt: ErrOr[Int] = Invalid("Invalid int.")
+   * scala> val invalidBool: ErrOr[Boolean] = Invalid("Invalid boolean.")
+   *
+   * scala> validInt.productL(validBool)
+   * res0: ErrOr[Int] = Valid(3)
+   *
+   * scala> invalidInt.productL(validBool)
+   * res1: ErrOr[Int] = Invalid(Invalid int.)
+   *
+   * scala> validInt.productL(invalidBool)
+   * res2: ErrOr[Int] = Invalid(Invalid boolean.)
+   *
+   * scala> invalidInt.productL(invalidBool)
+   * res3: ErrOr[Int] = Invalid(Invalid int.Invalid boolean.)
+   * }}}    
+   */
+  def productL[B](fb: F[B])(implicit F: Apply[F]): F[A] = F.productL(fa)(fb)
+
+  /**
+   * Alias for [[productR]].
+   */
+  def *>[B](fb: F[B])(implicit F: Apply[F]): F[B] = F.*>(fa)(fb)
+
+  /**
+   * Alias for [[productL]].
+   */
+  def <*[B](fb: F[B])(implicit F: Apply[F]): F[A] = F.<*(fa)(fb)
+
+  /**
+   * @see [[Apply.map2]].
+   * 
+   * Example:
+   * {{{
+   * scala> import cats.syntax.all._
+   *
+   * scala> val someInt: Option[Int] = Some(3)
+   * scala> val noneInt: Option[Int] = None
+   * scala> val someLong: Option[Long] = Some(4L)
+   * scala> val noneLong: Option[Long] = None
+   *
+   * scala> someInt.map2(someLong)((i, l) => i.toString + l.toString)
+   * res0: Option[String] = Some(34)
+   *
+   * scala> someInt.map2(noneLong)((i, l) => i.toString + l.toString)
+   * res0: Option[String] = None
+   *
+   * scala> noneInt.map2(noneLong)((i, l) => i.toString + l.toString)
+   * res0: Option[String] = None
+   *
+   * scala> noneInt.map2(someLong)((i, l) => i.toString + l.toString)
+   * res0: Option[String] = None
+   * }}} 
+   */
+  def map2[B, C](fb: F[B])(f: (A, B) => C)(implicit F: Apply[F]): F[C] =
+    F.map2(fa, fb)(f)
+
+  /**
+   * @see [[Apply.map2Eval]].
+   * 
+   * Example:
+   * {{{
+   * scala> import cats.{Eval, Later}
+   * scala> import cats.syntax.all._
+   * 
+   * scala> val bomb: Eval[Option[Int]] = Later(sys.error("boom"))
+   * scala> val x: Option[Int] = None
+   * 
+   * scala> x.map2Eval(bomb)(_ + _).value
+   * res0: Option[Int] = None 
+   * }}} 
+   */
+  def map2Eval[B, C](fb: Eval[F[B]])(f: (A, B) => C)(implicit F: Apply[F]): Eval[F[C]] =
+    F.map2Eval(fa, fb)(f)
+}
+
 final class IfApplyOps[F[_]](private val fcond: F[Boolean]) extends AnyVal {
 
   @deprecated("Dangerous method, use ifM (a flatMap) or ifF (a map) instead", "2.6.2")

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

@@ -27,7 +27,7 @@ package object syntax {
   object alternative extends AlternativeSyntax
   object applicative extends ApplicativeSyntax
   object applicativeError extends ApplicativeErrorSyntax
-  object apply extends ApplySyntax with ApplySyntaxBinCompat0
+  object apply extends ApplySyntax with ApplySyntaxBinCompat0 with ApplySyntaxBinCompat1
   object arrow extends ArrowSyntax
   object arrowChoice extends ArrowChoiceSyntax
   object bifunctor extends BifunctorSyntax

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

@@ -23,13 +23,52 @@ package cats
 package syntax
 
 trait SemigroupalSyntax {
-  implicit final def catsSyntaxSemigroupal[F[_], A](fa: F[A])(implicit F: Semigroupal[F]): SemigroupalOps[F, A] =
+  @deprecated("Use `catsSntaxSemigroupalOps2`", "2.10.0")
+  final def catsSyntaxSemigroupal[F[_], A](fa: F[A])(implicit F: Semigroupal[F]): SemigroupalOps[F, A] =
     new SemigroupalOps[F, A] {
       type TypeClassType = Semigroupal[F]
 
       val self = fa
       val typeClassInstance = F
     }
+
+  implicit def catsSntaxSemigroupalOps2[F[_], A](fa: F[A]): SemigroupalOps2[F, A] =
+    new SemigroupalOps2[F, A](fa)
+
+}
+
+final class SemigroupalOps2[F[_], A](private val fa: F[A]) extends AnyVal {
+
+  /**
+   * @see [[Semigroupal.product]]
+   *
+   * Example:
+   * {{{
+   * scala> import cats.syntax.all._
+   *
+   * scala> val noneInt: Option[Int] = None
+   * scala> val some3: Option[Int] = Some(3)
+   * scala> val noneString: Option[String] = None
+   * scala> val someFoo: Option[String] = Some("foo")
+   *
+   * scala> noneInt.product(noneString)
+   * res0: Option[(Int, String)] = None
+   *
+   * scala> noneInt.product(someFoo)
+   * res1: Option[(Int, String)] = None
+   *
+   * scala> some3.product(noneString)
+   * res2: Option[(Int, String)] = None
+   *
+   * scala> some3.product(someFoo)
+   * res3: Option[(Int, String)] = Some((3,foo))
+   * }}}
+   */
+  def product[B](fb: F[B])(implicit F: Semigroupal[F]): F[(A, B)] = F.product(fa, fb)
+
+  @deprecated("Replaced by an apply syntax, e.g. instead of (a |@| b).map(...) use (a, b).mapN(...)", "1.0.0-MF")
+  def |@|[B](fb: F[B]): SemigroupalBuilder[F]#SemigroupalBuilder2[A, B] =
+    new SemigroupalBuilder[F] |@| fa |@| fb
 }
 
 abstract class SemigroupalOps[F[_], A] extends Semigroupal.Ops[F, A] {