zip

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 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>>

Returns a list of pairs built from the elements of this array and the other array with the same index. The returned list has length of the shortest collection.

Samples

import samples.*
fun main() { 
   //sampleStart 
   val listA = listOf("a", "b", "c")
val listB = listOf(1, 2, 3, 4)
assertPrints(listA zip listB, "[(a, 1), (b, 2), (c, 3)]") 
   //sampleEnd
}

inline fun <T, R, V> Array<out T>.zip(other: Array<out R>, transform: (T, R) -> V): List<V>
inline fun <R, V> ByteArray.zip(other: Array<out R>, transform: (a: Byte, R) -> V): List<V>
inline fun <R, V> ShortArray.zip(other: Array<out R>, transform: (a: Short, R) -> V): List<V>
inline fun <R, V> IntArray.zip(other: Array<out R>, transform: (a: Int, R) -> V): List<V>
inline fun <R, V> LongArray.zip(other: Array<out R>, transform: (a: Long, R) -> V): List<V>
inline fun <R, V> FloatArray.zip(other: Array<out R>, transform: (a: Float, R) -> V): List<V>
inline fun <R, V> DoubleArray.zip(other: Array<out R>, transform: (a: Double, R) -> V): List<V>
inline fun <R, V> BooleanArray.zip(other: Array<out R>, transform: (a: Boolean, R) -> V): List<V>
inline fun <R, V> CharArray.zip(other: Array<out R>, transform: (a: Char, R) -> V): List<V>

Returns a list of values built from the elements of this array and the other array with the same index using the provided transform function applied to each pair of elements. The returned list has length of the shortest collection.

Samples

import samples.*
fun main() { 
   //sampleStart 
   val listA = listOf("a", "b", "c")
val listB = listOf(1, 2, 3, 4)
val result = listA.zip(listB) { a, b -> "$a$b" }
assertPrints(result, "[a1, b2, c3]") 
   //sampleEnd
}

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>>

Returns a list of pairs built from the elements of this collection and other array with the same index. The returned list has length of the shortest collection.

Samples

import samples.*
fun main() { 
   //sampleStart 
   val listA = listOf("a", "b", "c")
val listB = listOf(1, 2, 3, 4)
assertPrints(listA zip listB, "[(a, 1), (b, 2), (c, 3)]") 
   //sampleEnd
}

inline fun <T, R, V> Array<out T>.zip(other: Iterable<R>, transform: (T, R) -> V): List<V>
inline fun <R, V> ByteArray.zip(other: Iterable<R>, transform: (a: Byte, R) -> V): List<V>
inline fun <R, V> ShortArray.zip(other: Iterable<R>, transform: (a: Short, R) -> V): List<V>
inline fun <R, V> IntArray.zip(other: Iterable<R>, transform: (a: Int, R) -> V): List<V>
inline fun <R, V> LongArray.zip(other: Iterable<R>, transform: (a: Long, R) -> V): List<V>
inline fun <R, V> FloatArray.zip(other: Iterable<R>, transform: (a: Float, R) -> V): List<V>
inline fun <R, V> DoubleArray.zip(other: Iterable<R>, transform: (a: Double, R) -> V): List<V>
inline fun <R, V> BooleanArray.zip(other: Iterable<R>, transform: (a: Boolean, R) -> V): List<V>
inline fun <R, V> CharArray.zip(other: Iterable<R>, transform: (a: Char, R) -> V): List<V>

Returns a list of values built from the elements of this array and the other collection with the same index using the provided transform function applied to each pair of elements. The returned list has length of the shortest collection.

Samples

import samples.*
fun main() { 
   //sampleStart 
   val listA = listOf("a", "b", "c")
val listB = listOf(1, 2, 3, 4)
val result = listA.zip(listB) { a, b -> "$a$b" }
assertPrints(result, "[a1, b2, c3]") 
   //sampleEnd
}

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>

Returns a list of values built from the elements of this array and the other array with the same index using the provided transform function applied to each pair of elements. The returned list has length of the shortest array.

Samples

import samples.*
fun main() { 
   //sampleStart 
   val listA = listOf("a", "b", "c")
val listB = listOf(1, 2, 3, 4)
val result = listA.zip(listB) { a, b -> "$a$b" }
assertPrints(result, "[a1, b2, c3]") 
   //sampleEnd
}

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

Returns a list of pairs built from the elements of this collection and the other array with the same index. The returned list has length of the shortest collection.

Samples

import samples.*
fun main() { 
   //sampleStart 
   val listA = listOf("a", "b", "c")
val listB = listOf(1, 2, 3, 4)
assertPrints(listA zip listB, "[(a, 1), (b, 2), (c, 3)]") 
   //sampleEnd
}

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

Returns a list of values built from the elements of this collection and the other array with the same index using the provided transform function applied to each pair of elements. The returned list has length of the shortest collection.

Samples

import samples.*
fun main() { 
   //sampleStart 
   val listA = listOf("a", "b", "c")
val listB = listOf(1, 2, 3, 4)
val result = listA.zip(listB) { a, b -> "$a$b" }
assertPrints(result, "[a1, b2, c3]") 
   //sampleEnd
}

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

Returns a list of pairs built from the elements of this collection and other collection with the same index. The returned list has length of the shortest collection.

Samples

import samples.*
fun main() { 
   //sampleStart 
   val listA = listOf("a", "b", "c")
val listB = listOf(1, 2, 3, 4)
assertPrints(listA zip listB, "[(a, 1), (b, 2), (c, 3)]") 
   //sampleEnd
}

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

Returns a list of values built from the elements of this collection and the other collection with the same index using the provided transform function applied to each pair of elements. The returned list has length of the shortest collection.

Samples

import samples.*
fun main() { 
   //sampleStart 
   val listA = listOf("a", "b", "c")
val listB = listOf(1, 2, 3, 4)
val result = listA.zip(listB) { a, b -> "$a$b" }
assertPrints(result, "[a1, b2, c3]") 
   //sampleEnd
}

infix fun <R> UIntArray.zip(other: Array<out R>): List<Pair<UInt, R>>
infix fun <R> ULongArray.zip(other: Array<out R>): List<Pair<ULong, R>>
infix fun <R> UByteArray.zip(other: Array<out R>): List<Pair<UByte, R>>
infix fun <R> UShortArray.zip(other: Array<out R>): List<Pair<UShort, R>>
infix fun UIntArray.zip(other: UIntArray): List<Pair<UInt, UInt>>
infix fun ULongArray.zip(other: ULongArray): List<Pair<ULong, ULong>>
infix fun UByteArray.zip(other: UByteArray): List<Pair<UByte, UByte>>
infix fun UShortArray.zip(other: UShortArray): List<Pair<UShort, UShort>>

Returns a list of pairs built from the elements of this array and the other array with the same index. The returned list has length of the shortest collection.

Since Kotlin

1.3

Samples

import samples.*
fun main() { 
   //sampleStart 
   val listA = listOf("a", "b", "c")
val listB = listOf(1, 2, 3, 4)
assertPrints(listA zip listB, "[(a, 1), (b, 2), (c, 3)]") 
   //sampleEnd
}

inline fun <R, V> UIntArray.zip(other: Array<out R>, transform: (a: UInt, R) -> V): List<V>
inline fun <R, V> ULongArray.zip(other: Array<out R>, transform: (a: ULong, R) -> V): List<V>
inline fun <R, V> UByteArray.zip(other: Array<out R>, transform: (a: UByte, R) -> V): List<V>
inline fun <R, V> UShortArray.zip(other: Array<out R>, transform: (a: UShort, R) -> V): List<V>

Returns a list of values built from the elements of this array and the other array with the same index using the provided transform function applied to each pair of elements. The returned list has length of the shortest collection.

Since Kotlin

1.3

Samples

import samples.*
fun main() { 
   //sampleStart 
   val listA = listOf("a", "b", "c")
val listB = listOf(1, 2, 3, 4)
val result = listA.zip(listB) { a, b -> "$a$b" }
assertPrints(result, "[a1, b2, c3]") 
   //sampleEnd
}

infix fun <R> UIntArray.zip(other: Iterable<R>): List<Pair<UInt, R>>
infix fun <R> ULongArray.zip(other: Iterable<R>): List<Pair<ULong, R>>
infix fun <R> UByteArray.zip(other: Iterable<R>): List<Pair<UByte, R>>
infix fun <R> UShortArray.zip(other: Iterable<R>): List<Pair<UShort, R>>

Returns a list of pairs built from the elements of this collection and other array with the same index. The returned list has length of the shortest collection.

Since Kotlin

1.3

Samples

import samples.*
fun main() { 
   //sampleStart 
   val listA = listOf("a", "b", "c")
val listB = listOf(1, 2, 3, 4)
assertPrints(listA zip listB, "[(a, 1), (b, 2), (c, 3)]") 
   //sampleEnd
}

inline fun <R, V> UIntArray.zip(other: Iterable<R>, transform: (a: UInt, R) -> V): List<V>
inline fun <R, V> ULongArray.zip(other: Iterable<R>, transform: (a: ULong, R) -> V): List<V>
inline fun <R, V> UByteArray.zip(other: Iterable<R>, transform: (a: UByte, R) -> V): List<V>
inline fun <R, V> UShortArray.zip(other: Iterable<R>, transform: (a: UShort, R) -> V): List<V>

Returns a list of values built from the elements of this array and the other collection with the same index using the provided transform function applied to each pair of elements. The returned list has length of the shortest collection.

Since Kotlin

1.3

Samples

import samples.*
fun main() { 
   //sampleStart 
   val listA = listOf("a", "b", "c")
val listB = listOf(1, 2, 3, 4)
val result = listA.zip(listB) { a, b -> "$a$b" }
assertPrints(result, "[a1, b2, c3]") 
   //sampleEnd
}

inline fun <V> UIntArray.zip(other: UIntArray, transform: (a: UInt, b: UInt) -> V): List<V>
inline fun <V> ULongArray.zip(other: ULongArray, transform: (a: ULong, b: ULong) -> V): List<V>
inline fun <V> UByteArray.zip(other: UByteArray, transform: (a: UByte, b: UByte) -> V): List<V>
inline fun <V> UShortArray.zip(other: UShortArray, transform: (a: UShort, b: UShort) -> V): List<V>

Returns a list of values built from the elements of this array and the other array with the same index using the provided transform function applied to each pair of elements. The returned list has length of the shortest array.

Since Kotlin

1.3

Samples

import samples.*
fun main() { 
   //sampleStart 
   val listA = listOf("a", "b", "c")
val listB = listOf(1, 2, 3, 4)
val result = listA.zip(listB) { a, b -> "$a$b" }
assertPrints(result, "[a1, b2, c3]") 
   //sampleEnd
}