infix fun <T, R> Array<out T>.zip(
    other: Array<out R>
): List<Pair<T, R>>

infix fun <R> ByteArray.zip(
    other: Array<out R>
): List<Pair<Byte, R>>

infix fun <R> ShortArray.zip(
    other: Array<out R>
): List<Pair<Short, R>>

infix fun <R> IntArray.zip(
    other: Array<out R>
): List<Pair<Int, R>>

infix fun <R> LongArray.zip(
    other: Array<out R>
): List<Pair<Long, R>>

infix fun <R> FloatArray.zip(
    other: Array<out R>
): List<Pair<Float, R>>

infix fun <R> DoubleArray.zip(
    other: Array<out R>
): List<Pair<Double, R>>

infix fun <R> BooleanArray.zip(
    other: Array<out R>
): List<Pair<Boolean, R>>

infix fun <R> CharArray.zip(
    other: Array<out R>
): List<Pair<Char, R>>

infix fun <T, R> Array<out T>.zip(
    other: Iterable<R>
): List<Pair<T, R>>

infix fun <R> ByteArray.zip(
    other: Iterable<R>
): List<Pair<Byte, R>>

infix fun <R> ShortArray.zip(
    other: Iterable<R>
): List<Pair<Short, R>>

infix fun <R> IntArray.zip(
    other: Iterable<R>
): List<Pair<Int, R>>

infix fun <R> LongArray.zip(
    other: Iterable<R>
): List<Pair<Long, R>>

infix fun <R> FloatArray.zip(
    other: Iterable<R>
): List<Pair<Float, R>>

infix fun <R> DoubleArray.zip(
    other: Iterable<R>
): List<Pair<Double, R>>

infix fun <R> BooleanArray.zip(
    other: Iterable<R>
): List<Pair<Boolean, R>>

infix fun <R> CharArray.zip(
    other: Iterable<R>
): List<Pair<Char, R>>

infix fun ByteArray.zip(
    other: ByteArray
): List<Pair<Byte, Byte>>

infix fun ShortArray.zip(
    other: ShortArray
): List<Pair<Short, Short>>

infix fun IntArray.zip(other: IntArray): List<Pair<Int, Int>>

infix fun LongArray.zip(
    other: LongArray
): List<Pair<Long, Long>>

infix fun FloatArray.zip(
    other: FloatArray
): List<Pair<Float, Float>>

infix fun DoubleArray.zip(
    other: DoubleArray
): List<Pair<Double, Double>>

infix fun BooleanArray.zip(
    other: BooleanArray
): List<Pair<Boolean, Boolean>>

infix fun CharArray.zip(
    other: CharArray
): List<Pair<Char, Char>>

infix fun <T, R> Iterable<T>.zip(
    other: Array<out R>
): List<Pair<T, R>>

infix fun <T, R> Iterable<T>.zip(
    other: Iterable<R>
): List<Pair<T, R>>

Returns a list of pairs built from elements of both collections with same indexes. List has length of shortest collection.

inline fun <T, R, V> Array<out T>.zip(
    other: Array<out R>, 
    transform: (a: T, b: R) -> V
): List<V>

inline fun <R, V> ByteArray.zip(
    other: Array<out R>, 
    transform: (a: Byte, b: R) -> V
): List<V>

inline fun <R, V> ShortArray.zip(
    other: Array<out R>, 
    transform: (a: Short, b: R) -> V
): List<V>

inline fun <R, V> IntArray.zip(
    other: Array<out R>, 
    transform: (a: Int, b: R) -> V
): List<V>

inline fun <R, V> LongArray.zip(
    other: Array<out R>, 
    transform: (a: Long, b: R) -> V
): List<V>

inline fun <R, V> FloatArray.zip(
    other: Array<out R>, 
    transform: (a: Float, b: R) -> V
): List<V>

inline fun <R, V> DoubleArray.zip(
    other: Array<out R>, 
    transform: (a: Double, b: R) -> V
): List<V>

inline fun <R, V> BooleanArray.zip(
    other: Array<out R>, 
    transform: (a: Boolean, b: R) -> V
): List<V>

inline fun <R, V> CharArray.zip(
    other: Array<out R>, 
    transform: (a: Char, b: R) -> V
): List<V>

inline fun <T, R, V> Array<out T>.zip(
    other: Iterable<R>, 
    transform: (a: T, b: R) -> V
): List<V>

inline fun <R, V> ByteArray.zip(
    other: Iterable<R>, 
    transform: (a: Byte, b: R) -> V
): List<V>

inline fun <R, V> ShortArray.zip(
    other: Iterable<R>, 
    transform: (a: Short, b: R) -> V
): List<V>

inline fun <R, V> IntArray.zip(
    other: Iterable<R>, 
    transform: (a: Int, b: R) -> V
): List<V>

inline fun <R, V> LongArray.zip(
    other: Iterable<R>, 
    transform: (a: Long, b: R) -> V
): List<V>

inline fun <R, V> FloatArray.zip(
    other: Iterable<R>, 
    transform: (a: Float, b: R) -> V
): List<V>

inline fun <R, V> DoubleArray.zip(
    other: Iterable<R>, 
    transform: (a: Double, b: R) -> V
): List<V>

inline fun <R, V> BooleanArray.zip(
    other: Iterable<R>, 
    transform: (a: Boolean, b: R) -> V
): List<V>

inline fun <R, V> CharArray.zip(
    other: Iterable<R>, 
    transform: (a: Char, b: R) -> V
): List<V>

inline fun <V> ByteArray.zip(
    other: ByteArray, 
    transform: (a: Byte, b: Byte) -> V
): List<V>

inline fun <V> ShortArray.zip(
    other: ShortArray, 
    transform: (a: Short, b: Short) -> V
): List<V>

inline fun <V> IntArray.zip(
    other: IntArray, 
    transform: (a: Int, b: Int) -> V
): List<V>

inline fun <V> LongArray.zip(
    other: LongArray, 
    transform: (a: Long, b: Long) -> V
): List<V>

inline fun <V> FloatArray.zip(
    other: FloatArray, 
    transform: (a: Float, b: Float) -> V
): List<V>

inline fun <V> DoubleArray.zip(
    other: DoubleArray, 
    transform: (a: Double, b: Double) -> V
): List<V>

inline fun <V> BooleanArray.zip(
    other: BooleanArray, 
    transform: (a: Boolean, b: Boolean) -> V
): List<V>

inline fun <V> CharArray.zip(
    other: CharArray, 
    transform: (a: Char, b: Char) -> V
): List<V>

inline fun <T, R, V> Iterable<T>.zip(
    other: Array<out R>, 
    transform: (a: T, b: R) -> V
): List<V>

inline fun <T, R, V> Iterable<T>.zip(
    other: Iterable<R>, 
    transform: (a: T, b: R) -> V
): List<V>

Returns a list of values built from elements of both collections with same indexes using provided transform. List has length of shortest collection.