diff --git a/libraries/stdlib/src/generated/_Arrays.kt b/libraries/stdlib/src/generated/_Arrays.kt
index 865fb7060a6..db192876db3 100644
--- a/libraries/stdlib/src/generated/_Arrays.kt
+++ b/libraries/stdlib/src/generated/_Arrays.kt
@@ -9033,136 +9033,6 @@ public fun <T : Any> Array<out T?>.requireNoNulls(): Array<out T> {
     return this as Array<out T>
 }
 
-@Deprecated("Use zip() with transform instead.", ReplaceWith("zip(array, transform)"))
-public inline fun <T, R, V> Array<out T>.merge(array: Array<out R>, transform: (T, R) -> V): List<V> {
-    return zip(array, transform)
-}
-
-@Deprecated("Use zip() with transform instead.", ReplaceWith("zip(array, transform)"))
-public inline fun <R, V> BooleanArray.merge(array: Array<out R>, transform: (Boolean, R) -> V): List<V> {
-    return zip(array, transform)
-}
-
-@Deprecated("Use zip() with transform instead.", ReplaceWith("zip(array, transform)"))
-public inline fun <R, V> ByteArray.merge(array: Array<out R>, transform: (Byte, R) -> V): List<V> {
-    return zip(array, transform)
-}
-
-@Deprecated("Use zip() with transform instead.", ReplaceWith("zip(array, transform)"))
-public inline fun <R, V> CharArray.merge(array: Array<out R>, transform: (Char, R) -> V): List<V> {
-    return zip(array, transform)
-}
-
-@Deprecated("Use zip() with transform instead.", ReplaceWith("zip(array, transform)"))
-public inline fun <R, V> DoubleArray.merge(array: Array<out R>, transform: (Double, R) -> V): List<V> {
-    return zip(array, transform)
-}
-
-@Deprecated("Use zip() with transform instead.", ReplaceWith("zip(array, transform)"))
-public inline fun <R, V> FloatArray.merge(array: Array<out R>, transform: (Float, R) -> V): List<V> {
-    return zip(array, transform)
-}
-
-@Deprecated("Use zip() with transform instead.", ReplaceWith("zip(array, transform)"))
-public inline fun <R, V> IntArray.merge(array: Array<out R>, transform: (Int, R) -> V): List<V> {
-    return zip(array, transform)
-}
-
-@Deprecated("Use zip() with transform instead.", ReplaceWith("zip(array, transform)"))
-public inline fun <R, V> LongArray.merge(array: Array<out R>, transform: (Long, R) -> V): List<V> {
-    return zip(array, transform)
-}
-
-@Deprecated("Use zip() with transform instead.", ReplaceWith("zip(array, transform)"))
-public inline fun <R, V> ShortArray.merge(array: Array<out R>, transform: (Short, R) -> V): List<V> {
-    return zip(array, transform)
-}
-
-@Deprecated("Use zip() with transform instead.", ReplaceWith("zip(array, transform)"))
-public inline fun <V> BooleanArray.merge(array: BooleanArray, transform: (Boolean, Boolean) -> V): List<V> {
-    return zip(array, transform)
-}
-
-@Deprecated("Use zip() with transform instead.", ReplaceWith("zip(array, transform)"))
-public inline fun <V> ByteArray.merge(array: ByteArray, transform: (Byte, Byte) -> V): List<V> {
-    return zip(array, transform)
-}
-
-@Deprecated("Use zip() with transform instead.", ReplaceWith("zip(array, transform)"))
-public inline fun <V> CharArray.merge(array: CharArray, transform: (Char, Char) -> V): List<V> {
-    return zip(array, transform)
-}
-
-@Deprecated("Use zip() with transform instead.", ReplaceWith("zip(array, transform)"))
-public inline fun <V> DoubleArray.merge(array: DoubleArray, transform: (Double, Double) -> V): List<V> {
-    return zip(array, transform)
-}
-
-@Deprecated("Use zip() with transform instead.", ReplaceWith("zip(array, transform)"))
-public inline fun <V> FloatArray.merge(array: FloatArray, transform: (Float, Float) -> V): List<V> {
-    return zip(array, transform)
-}
-
-@Deprecated("Use zip() with transform instead.", ReplaceWith("zip(array, transform)"))
-public inline fun <V> IntArray.merge(array: IntArray, transform: (Int, Int) -> V): List<V> {
-    return zip(array, transform)
-}
-
-@Deprecated("Use zip() with transform instead.", ReplaceWith("zip(array, transform)"))
-public inline fun <V> LongArray.merge(array: LongArray, transform: (Long, Long) -> V): List<V> {
-    return zip(array, transform)
-}
-
-@Deprecated("Use zip() with transform instead.", ReplaceWith("zip(array, transform)"))
-public inline fun <V> ShortArray.merge(array: ShortArray, transform: (Short, Short) -> V): List<V> {
-    return zip(array, transform)
-}
-
-@Deprecated("Use zip() with transform instead.", ReplaceWith("zip(other, transform)"))
-public inline fun <T, R, V> Array<out T>.merge(other: Iterable<R>, transform: (T, R) -> V): List<V> {
-    return zip(other, transform)
-}
-
-@Deprecated("Use zip() with transform instead.", ReplaceWith("zip(other, transform)"))
-public inline fun <R, V> BooleanArray.merge(other: Iterable<R>, transform: (Boolean, R) -> V): List<V> {
-    return zip(other, transform)
-}
-
-@Deprecated("Use zip() with transform instead.", ReplaceWith("zip(other, transform)"))
-public inline fun <R, V> ByteArray.merge(other: Iterable<R>, transform: (Byte, R) -> V): List<V> {
-    return zip(other, transform)
-}
-
-@Deprecated("Use zip() with transform instead.", ReplaceWith("zip(other, transform)"))
-public inline fun <R, V> CharArray.merge(other: Iterable<R>, transform: (Char, R) -> V): List<V> {
-    return zip(other, transform)
-}
-
-@Deprecated("Use zip() with transform instead.", ReplaceWith("zip(other, transform)"))
-public inline fun <R, V> DoubleArray.merge(other: Iterable<R>, transform: (Double, R) -> V): List<V> {
-    return zip(other, transform)
-}
-
-@Deprecated("Use zip() with transform instead.", ReplaceWith("zip(other, transform)"))
-public inline fun <R, V> FloatArray.merge(other: Iterable<R>, transform: (Float, R) -> V): List<V> {
-    return zip(other, transform)
-}
-
-@Deprecated("Use zip() with transform instead.", ReplaceWith("zip(other, transform)"))
-public inline fun <R, V> IntArray.merge(other: Iterable<R>, transform: (Int, R) -> V): List<V> {
-    return zip(other, transform)
-}
-
-@Deprecated("Use zip() with transform instead.", ReplaceWith("zip(other, transform)"))
-public inline fun <R, V> LongArray.merge(other: Iterable<R>, transform: (Long, R) -> V): List<V> {
-    return zip(other, transform)
-}
-
-@Deprecated("Use zip() with transform instead.", ReplaceWith("zip(other, transform)"))
-public inline fun <R, V> ShortArray.merge(other: Iterable<R>, transform: (Short, R) -> V): List<V> {
-    return zip(other, transform)
-}
-
 /**
  * Splits the original collection into pair of collections,
  * where *first* collection contains elements for which [predicate] yielded `true`,
diff --git a/libraries/stdlib/src/generated/_Collections.kt b/libraries/stdlib/src/generated/_Collections.kt
index 9c28012ae76..fbd060ec309 100644
--- a/libraries/stdlib/src/generated/_Collections.kt
+++ b/libraries/stdlib/src/generated/_Collections.kt
@@ -1397,16 +1397,6 @@ public fun <T : Any> List<T?>.requireNoNulls(): List<T> {
     return this as List<T>
 }
 
-@Deprecated("Use zip() with transform instead.", ReplaceWith("zip(array, transform)"))
-public inline fun <T, R, V> Iterable<T>.merge(array: Array<out R>, transform: (T, R) -> V): List<V> {
-    return zip(array, transform)
-}
-
-@Deprecated("Use zip() with transform instead.", ReplaceWith("zip(other, transform)"))
-public inline fun <T, R, V> Iterable<T>.merge(other: Iterable<R>, transform: (T, R) -> V): List<V> {
-    return zip(other, transform)
-}
-
 /**
  * Returns a list containing all elements of the original collection except the elements contained in the given [array].
  */
diff --git a/libraries/stdlib/src/generated/_Sequences.kt b/libraries/stdlib/src/generated/_Sequences.kt
index a964d34c584..f3d1b3008eb 100644
--- a/libraries/stdlib/src/generated/_Sequences.kt
+++ b/libraries/stdlib/src/generated/_Sequences.kt
@@ -838,11 +838,6 @@ public fun <T : Any> Sequence<T?>.requireNoNulls(): Sequence<T> {
     return map { it ?: throw IllegalArgumentException("null element found in $this.") }
 }
 
-@Deprecated("Use zip() with transform instead.", ReplaceWith("zip(sequence, transform)"))
-public fun <T, R, V> Sequence<T>.merge(sequence: Sequence<R>, transform: (T, R) -> V): Sequence<V> {
-    return zip(sequence, transform)
-}
-
 /**
  * Returns a sequence containing all elements of original sequence except the elements contained in the given [array].
  * Note that the source sequence and the array being subtracted are iterated only when an `iterator` is requested from
diff --git a/libraries/tools/kotlin-stdlib-gen/src/templates/Generators.kt b/libraries/tools/kotlin-stdlib-gen/src/templates/Generators.kt
index 6f68e52d230..c14ac53b63f 100644
--- a/libraries/tools/kotlin-stdlib-gen/src/templates/Generators.kt
+++ b/libraries/tools/kotlin-stdlib-gen/src/templates/Generators.kt
@@ -443,15 +443,6 @@ fun generators(): List<GenericFunction> {
         }
     }
 
-    templates add f("merge(other: Iterable<R>, transform: (T, R) -> V)") {
-        exclude(Sequences, Strings)
-        typeParam("R")
-        typeParam("V")
-        returns("List<V>")
-        inline(true)
-        deprecate(Deprecation("Use zip() with transform instead.", replaceWith = "zip(other, transform)"))
-    }
-
     templates add f("zip(other: Iterable<R>, transform: (T, R) -> V)") {
         exclude(Sequences, Strings)
         doc {
@@ -488,15 +479,6 @@ fun generators(): List<GenericFunction> {
         }
     }
 
-    templates add f("merge(array: Array<out R>, transform: (T, R) -> V)") {
-        exclude(Sequences, Strings)
-        typeParam("R")
-        typeParam("V")
-        returns("List<V>")
-        inline(true)
-        deprecate(Deprecation("Use zip() with transform instead.", replaceWith = "zip(array, transform)"))
-    }
-
     templates add f("zip(array: Array<out R>, transform: (T, R) -> V)") {
         exclude(Sequences, Strings)
         doc {
@@ -533,14 +515,6 @@ fun generators(): List<GenericFunction> {
 
     }
 
-    templates add f("merge(array: SELF, transform: (T, T) -> V)") {
-        only(ArraysOfPrimitives)
-        typeParam("V")
-        returns("List<V>")
-        inline(true)
-        deprecate(Deprecation("Use zip() with transform instead.", replaceWith = "zip(array, transform)"))
-    }
-
     templates add f("zip(array: SELF, transform: (T, T) -> V)") {
         only(ArraysOfPrimitives)
         doc {
@@ -563,14 +537,6 @@ fun generators(): List<GenericFunction> {
         }
     }
 
-    templates add f("merge(sequence: Sequence<R>, transform: (T, R) -> V)") {
-        only(Sequences)
-        typeParam("R")
-        typeParam("V")
-        returns("Sequence<V>")
-        deprecate(Deprecation("Use zip() with transform instead.", replaceWith = "zip(sequence, transform)"))
-    }
-
     templates add f("zip(sequence: Sequence<R>, transform: (T, R) -> V)") {
         only(Sequences)
         doc {