Deprecate map2 and product in favor of zip

arrow-core-data/src/main/kotlin/arrow/core/Either.kt

@@ -1855,11 +1855,23 @@ fun <A, C, B : C> Either<A, B>.widen(): Either<A, C> =
 fun <AA, A : AA, B> Either<A, B>.leftWiden(): Either<AA, B> =
   this
 
+@Deprecated(
+  "Instead of product, please use zip",
+  ReplaceWith(
+    "zip(fb)"
+  )
+)
 fun <A, B, C> Either<A, B>.product(fb: Either<A, C>): Either<A, Tuple2<B, C>> =
   flatMap { a ->
     fb.map { b -> Tuple2(a, b) }
   }
 
+@Deprecated(
+  "Instead of map2, please use zip",
+  ReplaceWith(
+    "zip(fb, f)"
+  )
+)
 fun <A, B, C, D> Either<A, B>.map2(fb: Either<A, C>, f: (Tuple2<B, C>) -> D): Either<A, D> =
   product(fb).map(f)
 

arrow-core-data/src/main/kotlin/arrow/core/Iterable.kt

@@ -67,6 +67,12 @@ fun <E, A> Iterable<Validated<E, Iterable<A>>>.flatSequenceValidated(semigroup:
 fun <E> Iterable<Validated<E, *>>.sequenceValidated_(semigroup: Semigroup<E>): Validated<E, Unit> =
   traverseValidated_(semigroup, ::identity)
 
+@Deprecated(
+  "Instead of map2, please use zip",
+  ReplaceWith(
+    "zip(fb, f)"
+  )
+)
 inline fun <A, B, Z> Iterable<A>.map2(fb: Iterable<B>, f: (Tuple2<A, B>) -> Z): List<Z> =
   flatMap { a ->
     fb.map { b ->
@@ -450,6 +456,12 @@ fun <A, B> Iterable<Ior<A, B>>.unalign(): Tuple2<List<A>, List<B>> =
 inline fun <A, B, C> Iterable<C>.unalign(fa: (C) -> Ior<A, B>): Tuple2<List<A>, List<B>> =
   map(fa).unalign()
 
+@Deprecated(
+  "Instead of product, please use zip",
+  ReplaceWith(
+    "zip(fb)"
+  )
+)
 fun <A, B> Iterable<A>.product(fb: Iterable<B>): List<Tuple2<A, B>> =
   fb.ap(map { a: A -> { b: B -> Tuple2(a, b) } })
 

arrow-core-data/src/main/kotlin/arrow/core/Validated.kt

@@ -1111,9 +1111,21 @@ fun <E, A> Validated<E, A>.replicate(SE: Semigroup<E>, n: Int, MA: Monoid<A>): V
   if (n <= 0) MA.empty().valid()
   else Validated.mapN(SE, this@replicate, replicate(SE, n - 1, MA)) { a, xs -> MA.run { a + xs } }
 
+@Deprecated(
+  "Instead of product, please use zip",
+  ReplaceWith(
+    "zip(SE, fb)"
+  )
+)
 fun <E, A, B> Validated<E, A>.product(SE: Semigroup<E>, fb: Validated<E, B>): Validated<E, Tuple2<A, B>> =
   ap(SE, fb.map { b: B -> { a: A -> Tuple2(a, b) } })
 
+@Deprecated(
+  "Instead of map2, please use zip",
+  ReplaceWith(
+    "zip(SE, fb, f)"
+  )
+)
 fun <E, A, B, Z> Validated<E, A>.map2(SE: Semigroup<E>, fb: Validated<E, B>, f: (Tuple2<A, B>) -> Z): Validated<E, Z> =
   product(SE, fb).map(f)
 

arrow-core-data/src/main/kotlin/arrow/typeclasses/Apply.kt

@@ -291,9 +291,21 @@ interface Apply<F> : Functor<F> {
     a.product(b).product(c).product(d).product(e).product(f)
       .product(g).product(h).product(i).product(j).map(lbd)
 
+  @Deprecated(
+    "Instead of map2, please use zip",
+    ReplaceWith(
+      "zip(fb, f)"
+    )
+  )
   fun <A, B, Z> Kind<F, A>.map2(fb: Kind<F, B>, f: (Tuple2<A, B>) -> Z): Kind<F, Z> =
     product(fb).map(f)
 
+  @Deprecated(
+    "Instead of product, please use zip",
+    ReplaceWith(
+      "zip(fb)"
+    )
+  )
   fun <A, B> Kind<F, A>.product(fb: Kind<F, B>): Kind<F, Tuple2<A, B>> =
     ap(fb.map { b: B -> { a: A -> Tuple2(a, b) } })
 

arrow-core/src/main/kotlin/arrow/core/extensions/either/zip/EitherZip.kt

@@ -0,0 +1,40 @@
+package arrow.core.extensions.either.zip
+
+import arrow.core.Either
+import arrow.core.Tuple2
+
+@JvmName("zip")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated(
+  "@extension projected functions are deprecated",
+  ReplaceWith(
+    "this.zip(arg1, ::Tuple2)",
+    "arrow.core.zip", "arrow.core.Tuple2"
+  ),
+  DeprecationLevel.WARNING
+)
+fun <A, B, E> Either<E, A>.zip(arg1: Either<E, B>): Either<E, Tuple2<A, B>> =
+  TODO()
+
+@JvmName("zipWith")
+@Suppress(
+  "UNCHECKED_CAST",
+  "USELESS_CAST",
+  "EXTENSION_SHADOWED_BY_MEMBER",
+  "UNUSED_PARAMETER"
+)
+@Deprecated(
+  "@extension projected functions are deprecated",
+  ReplaceWith(
+    "this.zip(arg1, arg2)",
+    "arrow.core.zip"
+  ),
+  DeprecationLevel.WARNING
+)
+fun <A, B, C, E> Either<E, A>.zipWith(arg1: Either<E, B>, arg2: Function2<A, B, C>): Either<E, C> =
+  TODO()

arrow-core/src/main/kotlin/arrow/core/extensions/option/zip/OptionZip.kt

@@ -28,15 +28,15 @@ internal val zip_singleton: OptionZip = object : arrow.core.extensions.OptionZip
 @Deprecated(
   "@extension kinded projected functions are deprecated",
   ReplaceWith(
-  "zip(arg1)",
-  "arrow.core.zip"
+    "zip(arg1)",
+    "arrow.core.zip"
   ),
   DeprecationLevel.WARNING
 )
 fun <A, B> Kind<ForOption, A>.zip(arg1: Kind<ForOption, B>): Option<Tuple2<A, B>> =
-    arrow.core.Option.zip().run {
-  this@zip.zip<A, B>(arg1) as arrow.core.Option<arrow.core.Tuple2<A, B>>
-}
+  arrow.core.Option.zip().run {
+    this@zip.zip<A, B>(arg1) as arrow.core.Option<arrow.core.Tuple2<A, B>>
+  }
 
 @JvmName("zipWith")
 @Suppress(
@@ -48,15 +48,15 @@ fun <A, B> Kind<ForOption, A>.zip(arg1: Kind<ForOption, B>): Option<Tuple2<A, B>
 @Deprecated(
   "@extension kinded projected functions are deprecated",
   ReplaceWith(
-  "zipWith(arg1, arg2)",
-  "arrow.core.zipWith"
+    "zipWith(arg1, arg2)",
+    "arrow.core.zipWith"
   ),
   DeprecationLevel.WARNING
 )
-fun <A, B, C> Kind<ForOption, A>.zipWith(arg1: Kind<ForOption, B>, arg2: Function2<A, B, C>):
-    Option<C> = arrow.core.Option.zip().run {
-  this@zipWith.zipWith<A, B, C>(arg1, arg2) as arrow.core.Option<C>
-}
+fun <A, B, C> Kind<ForOption, A>.zipWith(arg1: Kind<ForOption, B>, arg2: Function2<A, B, C>): Option<C> =
+  arrow.core.Option.zip().run {
+    this@zipWith.zipWith<A, B, C>(arg1, arg2) as arrow.core.Option<C>
+  }
 
 @Suppress(
   "UNCHECKED_CAST",