data class Tuple7<out A1, out A2, out A3, out A4, out A5, out A6, out A7>(val a1: A1, val a2: A2, val a3: A3, val a4: A4, val a5: A5, val a6: A6, val a7: A7)

Represents a simple data structure to hold 7 values.

Tuple7Like

interface Tuple7Like<A1, A2, A3, A4, A5, A6, A7>

Represents a tuple like data structure which has 7 components.

Tuple8

data class Tuple8<out A1, out A2, out A3, out A4, out A5, out A6, out A7, out A8>(val a1: A1, val a2: A2, val a3: A3, val a4: A4, val a5: A5, val a6: A6, val a7: A7, val a8: A8)

Represents a simple data structure to hold 8 values.

Tuple8Like

interface Tuple8Like<A1, A2, A3, A4, A5, A6, A7, A8>

Represents a tuple like data structure which has 8 components.

Tuple9

data class Tuple9<out A1, out A2, out A3, out A4, out A5, out A6, out A7, out A8, out A9>(val a1: A1, val a2: A2, val a3: A3, val a4: A4, val a5: A5, val a6: A6, val a7: A7, val a8: A8, val a9: A9)

Represents a simple data structure to hold 9 values.

Tuple9Like

interface Tuple9Like<A1, A2, A3, A4, A5, A6, A7, A8, A9>

Represents a tuple like data structure which has 9 components.

Functions

append

fun <A1, A2, A3, A4, A5> Tuple4<A1, A2, A3, A4>.append(a5: A5): Tuple5<A1, A2, A3, A4, A5>

Transforms this Tuple4 into a Tuple5 by appending the given arguments.

fun <A1, A2, A3, A4, A5, A6> Tuple5<A1, A2, A3, A4, A5>.append(a6: A6): Tuple6<A1, A2, A3, A4, A5, A6>

Transforms this Tuple5 into a Tuple6 by appending the given arguments.

fun <A1, A2, A3, A4, A5, A6, A7> Tuple6<A1, A2, A3, A4, A5, A6>.append(a7: A7): Tuple7<A1, A2, A3, A4, A5, A6, A7>

Transforms this Tuple6 into a Tuple7 by appending the given arguments.

fun <A1, A2, A3, A4, A5, A6, A7, A8> Tuple7<A1, A2, A3, A4, A5, A6, A7>.append(a8: A8): Tuple8<A1, A2, A3, A4, A5, A6, A7, A8>

Transforms this Tuple7 into a Tuple8 by appending the given arguments.

fun <A1, A2, A3, A4, A5, A6, A7, A8, A9> Tuple8<A1, A2, A3, A4, A5, A6, A7, A8>.append(a9: A9): Tuple9<A1, A2, A3, A4, A5, A6, A7, A8, A9>

Transforms this Tuple8 into a Tuple9 by appending the given arguments.

fun <A1, A2, A3> Pair<A1, A2>.append(a3: A3): Triple<A1, A2, A3>

Transforms this Pair into a Triple by appending the given arguments.

fun <A1, A2, A3, A4> Triple<A1, A2, A3>.append(a4: A4): Tuple4<A1, A2, A3, A4>

Transforms this Triple into a Tuple4 by appending the given arguments.

fun <A1, A2, A3, A4, A5, A6> Tuple4<A1, A2, A3, A4>.append(a5: A5, a6: A6): Tuple6<A1, A2, A3, A4, A5, A6>

Transforms this Tuple4 into a Tuple6 by appending the given arguments.

fun <A1, A2, A3, A4, A5, A6, A7> Tuple5<A1, A2, A3, A4, A5>.append(a6: A6, a7: A7): Tuple7<A1, A2, A3, A4, A5, A6, A7>

Transforms this Tuple5 into a Tuple7 by appending the given arguments.

fun <A1, A2, A3, A4, A5, A6, A7, A8> Tuple6<A1, A2, A3, A4, A5, A6>.append(a7: A7, a8: A8): Tuple8<A1, A2, A3, A4, A5, A6, A7, A8>

Transforms this Tuple6 into a Tuple8 by appending the given arguments.

fun <A1, A2, A3, A4, A5, A6, A7, A8, A9> Tuple7<A1, A2, A3, A4, A5, A6, A7>.append(a8: A8, a9: A9): Tuple9<A1, A2, A3, A4, A5, A6, A7, A8, A9>

Transforms this Tuple7 into a Tuple9 by appending the given arguments.

fun <A1, A2, A3, A4> Pair<A1, A2>.append(a3: A3, a4: A4): Tuple4<A1, A2, A3, A4>

Transforms this Pair into a Tuple4 by appending the given arguments.

fun <A1, A2, A3, A4, A5> Triple<A1, A2, A3>.append(a4: A4, a5: A5): Tuple5<A1, A2, A3, A4, A5>

Transforms this Triple into a Tuple5 by appending the given arguments.

fun <A1, A2, A3, A4, A5, A6, A7> Tuple4<A1, A2, A3, A4>.append(a5: A5, a6: A6, a7: A7): Tuple7<A1, A2, A3, A4, A5, A6, A7>

Transforms this Tuple4 into a Tuple7 by appending the given arguments.

fun <A1, A2, A3, A4, A5, A6, A7, A8> Tuple5<A1, A2, A3, A4, A5>.append(a6: A6, a7: A7, a8: A8): Tuple8<A1, A2, A3, A4, A5, A6, A7, A8>

Transforms this Tuple5 into a Tuple8 by appending the given arguments.

fun <A1, A2, A3, A4, A5, A6, A7, A8, A9> Tuple6<A1, A2, A3, A4, A5, A6>.append(a7: A7, a8: A8, a9: A9): Tuple9<A1, A2, A3, A4, A5, A6, A7, A8, A9>

Transforms this Tuple6 into a Tuple9 by appending the given arguments.

fun <A1, A2, A3, A4, A5> Pair<A1, A2>.append(a3: A3, a4: A4, a5: A5): Tuple5<A1, A2, A3, A4, A5>

Transforms this Pair into a Tuple5 by appending the given arguments.

fun <A1, A2, A3, A4, A5, A6> Triple<A1, A2, A3>.append(a4: A4, a5: A5, a6: A6): Tuple6<A1, A2, A3, A4, A5, A6>

Transforms this Triple into a Tuple6 by appending the given arguments.

fun <A1, A2, A3, A4, A5, A6, A7, A8> Tuple4<A1, A2, A3, A4>.append(a5: A5, a6: A6, a7: A7, a8: A8): Tuple8<A1, A2, A3, A4, A5, A6, A7, A8>

Transforms this Tuple4 into a Tuple8 by appending the given arguments.

fun <A1, A2, A3, A4, A5, A6, A7, A8, A9> Tuple5<A1, A2, A3, A4, A5>.append(a6: A6, a7: A7, a8: A8, a9: A9): Tuple9<A1, A2, A3, A4, A5, A6, A7, A8, A9>

Transforms this Tuple5 into a Tuple9 by appending the given arguments.

fun <A1, A2, A3, A4, A5, A6> Pair<A1, A2>.append(a3: A3, a4: A4, a5: A5, a6: A6): Tuple6<A1, A2, A3, A4, A5, A6>

Transforms this Pair into a Tuple6 by appending the given arguments.

fun <A1, A2, A3, A4, A5, A6, A7> Triple<A1, A2, A3>.append(a4: A4, a5: A5, a6: A6, a7: A7): Tuple7<A1, A2, A3, A4, A5, A6, A7>

Transforms this Triple into a Tuple7 by appending the given arguments.

fun <A1, A2, A3, A4, A5, A6, A7, A8, A9> Tuple4<A1, A2, A3, A4>.append(a5: A5, a6: A6, a7: A7, a8: A8, a9: A9): Tuple9<A1, A2, A3, A4, A5, A6, A7, A8, A9>

Transforms this Tuple4 into a Tuple9 by appending the given arguments.

fun <A1, A2, A3, A4, A5, A6, A7> Pair<A1, A2>.append(a3: A3, a4: A4, a5: A5, a6: A6, a7: A7): Tuple7<A1, A2, A3, A4, A5, A6, A7>

Transforms this Pair into a Tuple7 by appending the given arguments.

fun <A1, A2, A3, A4, A5, A6, A7, A8> Triple<A1, A2, A3>.append(a4: A4, a5: A5, a6: A6, a7: A7, a8: A8): Tuple8<A1, A2, A3, A4, A5, A6, A7, A8>

Transforms this Triple into a Tuple8 by appending the given arguments.

fun <A1, A2, A3, A4, A5, A6, A7, A8> Pair<A1, A2>.append(a3: A3, a4: A4, a5: A5, a6: A6, a7: A7, a8: A8): Tuple8<A1, A2, A3, A4, A5, A6, A7, A8>

Transforms this Pair into a Tuple8 by appending the given arguments.

fun <A1, A2, A3, A4, A5, A6, A7, A8, A9> Triple<A1, A2, A3>.append(a4: A4, a5: A5, a6: A6, a7: A7, a8: A8, a9: A9): Tuple9<A1, A2, A3, A4, A5, A6, A7, A8, A9>

Transforms this Triple into a Tuple9 by appending the given arguments.

fun <A1, A2, A3, A4, A5, A6, A7, A8, A9> Pair<A1, A2>.append(a3: A3, a4: A4, a5: A5, a6: A6, a7: A7, a8: A8, a9: A9): Tuple9<A1, A2, A3, A4, A5, A6, A7, A8, A9>

Transforms this Pair into a Tuple9 by appending the given arguments.

appendToStringBuilder

inline fun <T> Array<T>.appendToStringBuilder(sb: StringBuilder, separator: String, append: (it: T) -> Unit)

Appends all elements of this list to the given sb by calling append and separates the elements with the given separator.

inline fun <T> Iterable<T>.appendToStringBuilder(sb: StringBuilder, separator: String, append: (it: T) -> Unit)

Appends all elements of this Iterable to the given sb by calling append and separates the elements with the given separator.

inline fun <T> List<T>.appendToStringBuilder(sb: StringBuilder, separator: String, append: (it: T) -> Unit)

Appends all elements of this List to the given sb by calling append and separates the elements with the given separator.

inline fun <T> Sequence<T>.appendToStringBuilder(sb: StringBuilder, separator: String, append: (it: T) -> Unit)

Appends all elements of this Sequence to the given sb by calling append and separates the elements with the given separator.

inline fun <T> Array<T>.appendToStringBuilder(sb: StringBuilder, separator: String, lastSeparator: String, append: (it: T) -> Unit)

Appends all elements of this list to the given sb by calling append and separates the elements with the given separator whereas lastSeparator is used to separate the last and the second last element.

inline fun <T> List<T>.appendToStringBuilder(sb: StringBuilder, separator: String, lastSeparator: String, append: (it: T) -> Unit)

Appends all elements of this List to the given sb by calling append and separates the elements with the given separator whereas lastSeparator is used to separate the last and the second last element.

blankToNull

inline fun <T : CharSequence> T.blankToNull(): T?

Returns this CharSequence if it is not blank, null otherwise.

dynamicTraversal

@JvmName(name = "dynamicTraversalIterable")

fun <T> Sequence<T>.dynamicTraversal(revisit: Boolean = false, dropRoots: Boolean = true, traversalAlgorithm: TraversalAlgorithmOption = TraversalAlgorithmOption.BreadthFirst, loadElements: (element: T) -> Iterable<T>): Sequence<T>

Returns a single sequence containing all elements loadElements recursively provides for the elements of the original sequence as well as the elements as such if dropRoots = false is specified. The operation is intermediate and stateless.

Returns a single sequence containing all elements loadElements recursively provides for the elements of the original sequence as well as the elements itself if dropRoots = false is specified. The operation is intermediate and stateless.

failIf

inline fun failIf(predicate: Boolean, errorMessage: () -> String)

Delegates to check but inverting the predicate, i.e. throws an IllegalStateException if predicate is true.

flatten

@JvmName(name = "flatten4")

fun <T> Iterable<Tuple4<T, T, T, T>>.flatten(): List<T>

Flattens an Iterable of Tuple4 into a List<T>.

@JvmName(name = "flatten5")

fun <T> Iterable<Tuple5<T, T, T, T, T>>.flatten(): List<T>

Flattens an Iterable of Tuple5 into a List<T>.

@JvmName(name = "flatten6")

fun <T> Iterable<Tuple6<T, T, T, T, T, T>>.flatten(): List<T>

Flattens an Iterable of Tuple6 into a List<T>.

@JvmName(name = "flatten7")

fun <T> Iterable<Tuple7<T, T, T, T, T, T, T>>.flatten(): List<T>

Flattens an Iterable of Tuple7 into a List<T>.

@JvmName(name = "flatten8")

fun <T> Iterable<Tuple8<T, T, T, T, T, T, T, T>>.flatten(): List<T>

Flattens an Iterable of Tuple8 into a List<T>.

@JvmName(name = "flatten9")

fun <T> Iterable<Tuple9<T, T, T, T, T, T, T, T, T>>.flatten(): List<T>

Flattens an Iterable of Tuple9 into a List<T>.

@JvmName(name = "flatten2")

fun <T> Iterable<Pair<T, T>>.flatten(): List<T>

Flattens an Iterable of Pair into a List<T>.

@JvmName(name = "flatten3")

fun <T> Iterable<Triple<T, T, T>>.flatten(): List<T>

Flattens an Iterable of Triple into a List<T>.

@JvmName(name = "flatten4")

fun <T> List<Tuple4<T, T, T, T>>.flatten(): List<T>

Flattens a List of Tuple4 into a List<T>.

@JvmName(name = "flatten5")

fun <T> List<Tuple5<T, T, T, T, T>>.flatten(): List<T>

Flattens a List of Tuple5 into a List<T>.

@JvmName(name = "flatten6")

fun <T> List<Tuple6<T, T, T, T, T, T>>.flatten(): List<T>

Flattens a List of Tuple6 into a List<T>.

@JvmName(name = "flatten7")

fun <T> List<Tuple7<T, T, T, T, T, T, T>>.flatten(): List<T>

Flattens a List of Tuple7 into a List<T>.

@JvmName(name = "flatten8")

fun <T> List<Tuple8<T, T, T, T, T, T, T, T>>.flatten(): List<T>

Flattens a List of Tuple8 into a List<T>.

@JvmName(name = "flatten9")

fun <T> List<Tuple9<T, T, T, T, T, T, T, T, T>>.flatten(): List<T>

Flattens a List of Tuple9 into a List<T>.

@JvmName(name = "flatten2")

fun <T> List<Pair<T, T>>.flatten(): List<T>

Flattens a List of Pair into a List<T>.

@JvmName(name = "flatten3")

fun <T> List<Triple<T, T, T>>.flatten(): List<T>

Flattens a List of Triple into a List<T>.

@JvmName(name = "flatten4")

fun <T> Sequence<Tuple4<T, T, T, T>>.flatten(): Sequence<T>

Flattens a Sequence of Tuple4 into a Sequence<T>.

@JvmName(name = "flatten5")

fun <T> Sequence<Tuple5<T, T, T, T, T>>.flatten(): Sequence<T>

Flattens a Sequence of Tuple5 into a Sequence<T>.

@JvmName(name = "flatten6")

fun <T> Sequence<Tuple6<T, T, T, T, T, T>>.flatten(): Sequence<T>

Flattens a Sequence of Tuple6 into a Sequence<T>.

@JvmName(name = "flatten7")

fun <T> Sequence<Tuple7<T, T, T, T, T, T, T>>.flatten(): Sequence<T>

Flattens a Sequence of Tuple7 into a Sequence<T>.

@JvmName(name = "flatten8")

fun <T> Sequence<Tuple8<T, T, T, T, T, T, T, T>>.flatten(): Sequence<T>

Flattens a Sequence of Tuple8 into a Sequence<T>.

@JvmName(name = "flatten9")

fun <T> Sequence<Tuple9<T, T, T, T, T, T, T, T, T>>.flatten(): Sequence<T>

Flattens a Sequence of Tuple9 into a Sequence<T>.

@JvmName(name = "flatten2")

fun <T> Sequence<Pair<T, T>>.flatten(): Sequence<T>

Flattens a Sequence of Pair into a Sequence<T>.

@JvmName(name = "flatten3")

fun <T> Sequence<Triple<T, T, T>>.flatten(): Sequence<T>

Flattens a Sequence of Triple into a Sequence<T>.

forEachIn

inline fun <T> forEachIn(arr1: Array<out T>, arr2: Array<out T>, action: (T) -> Unit)

Applies action to each entry in arr1 and in arr2.

inline fun <T> forEachIn(iterable1: Iterable<T>, iterable2: Iterable<T>, action: (T) -> Unit)

Applies action to each entry in iterable1 and in iterable2.

inline fun <T> forEachIn(sequence1: Sequence<T>, sequence2: Sequence<T>, action: (T) -> Unit)

Applies action to each entry in sequence1 and to each entry in sequence2.

inline fun <T> forEachIn(arr1: Array<out T>, arr2: Array<out T>, arr3: Array<out T>, action: (T) -> Unit)

Applies action to each entry in arr1, arr2 and in arr3.

inline fun <T> forEachIn(iterable1: Iterable<T>, iterable2: Iterable<T>, iterable3: Iterable<T>, action: (T) -> Unit)

Applies action to each entry in iterable1, iterable2 and in iterable3.

inline fun <T> forEachIn(sequence1: Sequence<T>, sequence2: Sequence<T>, sequence3: Sequence<T>, action: (T) -> Unit)

Applies action to each entry in sequence1, sequence2 and in sequence3.

inline fun <T> forEachIn(arr1: Array<out T>, arr2: Array<out T>, arr3: Array<out T>, vararg arrays: Array<out T>, action: (T) -> Unit)

Applies action to each entry in arr1, arr2, arr3 and to each entry of Array in arrays.

inline fun <T> forEachIn(iterable1: Iterable<T>, iterable2: Iterable<T>, iterable3: Iterable<T>, vararg iterables: Iterable<T>, action: (T) -> Unit)

Applies action to each entry in iterable1, iterable2, iterable3 and to each entry of Iterable in iterables.

inline fun <T> forEachIn(sequence1: Sequence<T>, sequence2: Sequence<T>, sequence3: Sequence<T>, vararg sequences: Sequence<T>, action: (T) -> Unit)

Applies action to each entry in sequence1, sequence2, sequence3 and to each entry of Sequence in sequences.

forEachRemaining

inline fun <T> Iterator<T>.forEachRemaining(operation: (T) -> Unit)

Performs the given operation on each remaining element.

forElementAndForEachIn

inline fun <E> forElementAndForEachIn(element: E, arr: Array<out E>, action: (E) -> Unit)

Applies action to this and to each entry in arr.

inline fun <E> forElementAndForEachIn(element: E, iterable: Iterable<E>, action: (E) -> Unit)

Applies action to this and to each entry in iterable.

inline fun <E> forElementAndForEachIn(element: E, sequence: Sequence<E>, action: (E) -> Unit)

Applies action to this and to each entry in sequence.

inline fun <E> forElementAndForEachIn(element: E, arr1: Array<out E>, arr2: Array<out E>, action: (E) -> Unit)

Applies action to this and to each entry in arr1 and in arr2.

inline fun <E> forElementAndForEachIn(element: E, iterable1: Iterable<E>, iterable2: Iterable<E>, action: (E) -> Unit)

Applies action to this and to each entry in iterable1 and in iterable2.

inline fun <E> forElementAndForEachIn(element: E, sequence1: Sequence<E>, sequence2: Sequence<E>, action: (E) -> Unit)

Applies action to this and to each entry in sequence1 and in sequence2.

inline fun <E> forElementAndForEachIn(element: E, arr1: Array<out E>, arr2: Array<out E>, vararg arrays: Array<out E>, action: (E) -> Unit)

Applies action to this and to each entry in arr1, arr2 and each entry of Iterable in arrays.

inline fun <E> forElementAndForEachIn(element: E, iterable1: Iterable<E>, iterable2: Iterable<E>, vararg iterables: Iterable<E>, action: (E) -> Unit)

Applies action to this and to each entry in iterable1, iterable2 and each entry of Iterable in iterables.

inline fun <E> forElementAndForEachIn(element: E, sequence1: Sequence<E>, sequence2: Sequence<E>, vararg sequences: Sequence<E>, action: (E) -> Unit)

Applies action to this and to each entry in sequence1, sequence2 and each entry of Sequence in sequences.

glue

infix inline fun <T> T.glue(otherArgs: Array<out T>): List<T>

infix inline fun Boolean.glue(otherArgs: BooleanArray): List<Boolean>

infix inline fun Byte.glue(otherArgs: ByteArray): List<Byte>

infix inline fun Char.glue(otherArgs: CharArray): List<Char>

infix inline fun Double.glue(otherArgs: DoubleArray): List<Double>

infix inline fun Float.glue(otherArgs: FloatArray): List<Float>

infix inline fun Int.glue(otherArgs: IntArray): List<Int>

infix inline fun Long.glue(otherArgs: LongArray): List<Long>

infix inline fun Short.glue(otherArgs: ShortArray): List<Short>

Delegates to varargToList -- adds this and the otherArgs into a new List and returns it.

fun <A1, A2, A3, A4, A5, A6, A7, A8> Tuple4<A1, A2, A3, A4>.glue(tuple4: Tuple4<A5, A6, A7, A8>): Tuple8<A1, A2, A3, A4, A5, A6, A7, A8>

Glues the given tuple4 to this Tuple4 and thus results in a Tuple8.

fun <A1, A2, A3, A4, A5, A6, A7, A8, A9> Tuple4<A1, A2, A3, A4>.glue(tuple5: Tuple5<A5, A6, A7, A8, A9>): Tuple9<A1, A2, A3, A4, A5, A6, A7, A8, A9>

Glues the given tuple5 to this Tuple4 and thus results in a Tuple9.

fun <A1, A2, A3, A4, A5, A6> Tuple4<A1, A2, A3, A4>.glue(pair: Pair<A5, A6>): Tuple6<A1, A2, A3, A4, A5, A6>

Glues the given pair to this Tuple4 and thus results in a Tuple6.

fun <A1, A2, A3, A4, A5, A6, A7> Tuple4<A1, A2, A3, A4>.glue(triple: Triple<A5, A6, A7>): Tuple7<A1, A2, A3, A4, A5, A6, A7>

Glues the given triple to this Tuple4 and thus results in a Tuple7.

fun <A1, A2, A3, A4, A5, A6, A7, A8, A9> Tuple5<A1, A2, A3, A4, A5>.glue(tuple4: Tuple4<A6, A7, A8, A9>): Tuple9<A1, A2, A3, A4, A5, A6, A7, A8, A9>

Glues the given tuple4 to this Tuple5 and thus results in a Tuple9.

fun <A1, A2, A3, A4, A5, A6, A7> Tuple5<A1, A2, A3, A4, A5>.glue(pair: Pair<A6, A7>): Tuple7<A1, A2, A3, A4, A5, A6, A7>

Glues the given pair to this Tuple5 and thus results in a Tuple7.

fun <A1, A2, A3, A4, A5, A6, A7, A8> Tuple5<A1, A2, A3, A4, A5>.glue(triple: Triple<A6, A7, A8>): Tuple8<A1, A2, A3, A4, A5, A6, A7, A8>

Glues the given triple to this Tuple5 and thus results in a Tuple8.

fun <A1, A2, A3, A4, A5, A6, A7, A8> Tuple6<A1, A2, A3, A4, A5, A6>.glue(pair: Pair<A7, A8>): Tuple8<A1, A2, A3, A4, A5, A6, A7, A8>

Glues the given pair to this Tuple6 and thus results in a Tuple8.

fun <A1, A2, A3, A4, A5, A6, A7, A8, A9> Tuple6<A1, A2, A3, A4, A5, A6>.glue(triple: Triple<A7, A8, A9>): Tuple9<A1, A2, A3, A4, A5, A6, A7, A8, A9>

Glues the given triple to this Tuple6 and thus results in a Tuple9.

fun <A1, A2, A3, A4, A5, A6, A7, A8, A9> Tuple7<A1, A2, A3, A4, A5, A6, A7>.glue(pair: Pair<A8, A9>): Tuple9<A1, A2, A3, A4, A5, A6, A7, A8, A9>

Glues the given pair to this Tuple7 and thus results in a Tuple9.

fun <A1, A2, A3, A4, A5, A6> Pair<A1, A2>.glue(tuple4: Tuple4<A3, A4, A5, A6>): Tuple6<A1, A2, A3, A4, A5, A6>

Glues the given tuple4 to this Pair and thus results in a Tuple6.

fun <A1, A2, A3, A4, A5, A6, A7> Pair<A1, A2>.glue(tuple5: Tuple5<A3, A4, A5, A6, A7>): Tuple7<A1, A2, A3, A4, A5, A6, A7>

Glues the given tuple5 to this Pair and thus results in a Tuple7.

fun <A1, A2, A3, A4, A5, A6, A7, A8> Pair<A1, A2>.glue(tuple6: Tuple6<A3, A4, A5, A6, A7, A8>): Tuple8<A1, A2, A3, A4, A5, A6, A7, A8>

Glues the given tuple6 to this Pair and thus results in a Tuple8.

fun <A1, A2, A3, A4, A5, A6, A7, A8, A9> Pair<A1, A2>.glue(tuple7: Tuple7<A3, A4, A5, A6, A7, A8, A9>): Tuple9<A1, A2, A3, A4, A5, A6, A7, A8, A9>

Glues the given tuple7 to this Pair and thus results in a Tuple9.

fun <A1, A2, A3, A4> Pair<A1, A2>.glue(pair: Pair<A3, A4>): Tuple4<A1, A2, A3, A4>

Glues the given pair to this Pair and thus results in a Tuple4.

fun <A1, A2, A3, A4, A5> Pair<A1, A2>.glue(triple: Triple<A3, A4, A5>): Tuple5<A1, A2, A3, A4, A5>

Glues the given triple to this Pair and thus results in a Tuple5.

fun <A1, A2, A3, A4, A5, A6, A7> Triple<A1, A2, A3>.glue(tuple4: Tuple4<A4, A5, A6, A7>): Tuple7<A1, A2, A3, A4, A5, A6, A7>

Glues the given tuple4 to this Triple and thus results in a Tuple7.

fun <A1, A2, A3, A4, A5, A6, A7, A8> Triple<A1, A2, A3>.glue(tuple5: Tuple5<A4, A5, A6, A7, A8>): Tuple8<A1, A2, A3, A4, A5, A6, A7, A8>

Glues the given tuple5 to this Triple and thus results in a Tuple8.

fun <A1, A2, A3, A4, A5, A6, A7, A8, A9> Triple<A1, A2, A3>.glue(tuple6: Tuple6<A4, A5, A6, A7, A8, A9>): Tuple9<A1, A2, A3, A4, A5, A6, A7, A8, A9>

Glues the given tuple6 to this Triple and thus results in a Tuple9.

fun <A1, A2, A3, A4, A5> Triple<A1, A2, A3>.glue(pair: Pair<A4, A5>): Tuple5<A1, A2, A3, A4, A5>

Glues the given pair to this Triple and thus results in a Tuple5.

fun <A1, A2, A3, A4, A5, A6> Triple<A1, A2, A3>.glue(triple: Triple<A4, A5, A6>): Tuple6<A1, A2, A3, A4, A5, A6>

Glues the given triple to this Triple and thus results in a Tuple6.

identity

inline fun <T> identity(t: T): T

An identity function which inlines if possible.

ifNotEmpty

inline fun <T : Collection<*>, SuperTypeOfT, SuperTypeOfT : Iterable<*>> T.ifNotEmpty(transformation: (T) -> SuperTypeOfT): SuperTypeOfT

Checks if this collection is empty and if not applies the given transformation.

ifWithinBound

inline fun <E, R> Array<E>.ifWithinBound(index: Int, thenBlock: () -> R, elseBlock: () -> R): R

inline fun <E, R> List<E>.ifWithinBound(index: Int, thenBlock: () -> R, elseBlock: () -> R): R

Checks if the given index is within the bound of this List (index<List.size) and correspondingly executes the thenBlock or the elseBlock.

isNotNullAndNotBlank

fun CharSequence?.isNotNullAndNotBlank(): Boolean

Returns true if this CharSequence is neither null nor blank.

isNotNullAndNotEmpty

fun CharSequence?.isNotNullAndNotEmpty(): Boolean

Returns true if this CharSequence is neither null nor empty.

joinToString

inline fun <T> Array<T>.joinToString(separator: String, append: (it: T, sb: StringBuilder) -> Unit): String

Joins all elements of this list by calling append and separates the elements with the given separator.

inline fun <T> Iterable<T>.joinToString(separator: String, append: (it: T, sb: StringBuilder) -> Unit): String

Joins all elements of this Iterable by calling append and separates the elements with the given separator.

inline fun <T> List<T>.joinToString(separator: String, append: (it: T, sb: StringBuilder) -> Unit): String

Joins all elements of this List by calling append and separates the elements with the given separator.

inline fun <T> Sequence<T>.joinToString(separator: String, append: (it: T, sb: StringBuilder) -> Unit): String

Joins all elements of this Sequence by calling append and separates the elements with the given separator.

inline fun <T> Array<T>.joinToString(separator: String, lastSeparator: String, append: (it: T, sb: StringBuilder) -> Unit): String

Joins all elements of this list by calling append and separates the elements with the given separator whereas lastSeparator is used to separate the last and the second last element.

inline fun <T> List<T>.joinToString(separator: String, lastSeparator: String, append: (it: T, sb: StringBuilder) -> Unit): String

Joins all elements of this List by calling append and separates the elements with the given separator whereas lastSeparator is used to separate the last and the second last element.

mapA1

fun <A1, A2, A3, A4, A1New> Tuple4<A1, A2, A3, A4>.mapA1(transform: (A1) -> A1New): Tuple4<A1New, A2, A3, A4>

Maps Tuple4.a1 with the given transform function and returns a new Tuple4.

fun <A1, A2, A3, A4, A5, A1New> Tuple5<A1, A2, A3, A4, A5>.mapA1(transform: (A1) -> A1New): Tuple5<A1New, A2, A3, A4, A5>

Maps Tuple5.a1 with the given transform function and returns a new Tuple5.

fun <A1, A2, A3, A4, A5, A6, A1New> Tuple6<A1, A2, A3, A4, A5, A6>.mapA1(transform: (A1) -> A1New): Tuple6<A1New, A2, A3, A4, A5, A6>

Maps Tuple6.a1 with the given transform function and returns a new Tuple6.

fun <A1, A2, A3, A4, A5, A6, A7, A1New> Tuple7<A1, A2, A3, A4, A5, A6, A7>.mapA1(transform: (A1) -> A1New): Tuple7<A1New, A2, A3, A4, A5, A6, A7>

Maps Tuple7.a1 with the given transform function and returns a new Tuple7.

fun <A1, A2, A3, A4, A5, A6, A7, A8, A1New> Tuple8<A1, A2, A3, A4, A5, A6, A7, A8>.mapA1(transform: (A1) -> A1New): Tuple8<A1New, A2, A3, A4, A5, A6, A7, A8>

Maps Tuple8.a1 with the given transform function and returns a new Tuple8.

fun <A1, A2, A3, A4, A5, A6, A7, A8, A9, A1New> Tuple9<A1, A2, A3, A4, A5, A6, A7, A8, A9>.mapA1(transform: (A1) -> A1New): Tuple9<A1New, A2, A3, A4, A5, A6, A7, A8, A9>

Maps Tuple9.a1 with the given transform function and returns a new Tuple9.

mapA2

fun <A1, A2, A3, A4, A2New> Tuple4<A1, A2, A3, A4>.mapA2(transform: (A2) -> A2New): Tuple4<A1, A2New, A3, A4>

Maps Tuple4.a2 with the given transform function and returns a new Tuple4.

fun <A1, A2, A3, A4, A5, A2New> Tuple5<A1, A2, A3, A4, A5>.mapA2(transform: (A2) -> A2New): Tuple5<A1, A2New, A3, A4, A5>

Maps Tuple5.a2 with the given transform function and returns a new Tuple5.

fun <A1, A2, A3, A4, A5, A6, A2New> Tuple6<A1, A2, A3, A4, A5, A6>.mapA2(transform: (A2) -> A2New): Tuple6<A1, A2New, A3, A4, A5, A6>

Maps Tuple6.a2 with the given transform function and returns a new Tuple6.

fun <A1, A2, A3, A4, A5, A6, A7, A2New> Tuple7<A1, A2, A3, A4, A5, A6, A7>.mapA2(transform: (A2) -> A2New): Tuple7<A1, A2New, A3, A4, A5, A6, A7>

Maps Tuple7.a2 with the given transform function and returns a new Tuple7.

fun <A1, A2, A3, A4, A5, A6, A7, A8, A2New> Tuple8<A1, A2, A3, A4, A5, A6, A7, A8>.mapA2(transform: (A2) -> A2New): Tuple8<A1, A2New, A3, A4, A5, A6, A7, A8>

Maps Tuple8.a2 with the given transform function and returns a new Tuple8.

fun <A1, A2, A3, A4, A5, A6, A7, A8, A9, A2New> Tuple9<A1, A2, A3, A4, A5, A6, A7, A8, A9>.mapA2(transform: (A2) -> A2New): Tuple9<A1, A2New, A3, A4, A5, A6, A7, A8, A9>

Maps Tuple9.a2 with the given transform function and returns a new Tuple9.

mapA3

fun <A1, A2, A3, A4, A3New> Tuple4<A1, A2, A3, A4>.mapA3(transform: (A3) -> A3New): Tuple4<A1, A2, A3New, A4>

Maps Tuple4.a3 with the given transform function and returns a new Tuple4.

fun <A1, A2, A3, A4, A5, A3New> Tuple5<A1, A2, A3, A4, A5>.mapA3(transform: (A3) -> A3New): Tuple5<A1, A2, A3New, A4, A5>

Maps Tuple5.a3 with the given transform function and returns a new Tuple5.

fun <A1, A2, A3, A4, A5, A6, A3New> Tuple6<A1, A2, A3, A4, A5, A6>.mapA3(transform: (A3) -> A3New): Tuple6<A1, A2, A3New, A4, A5, A6>

Maps Tuple6.a3 with the given transform function and returns a new Tuple6.

fun <A1, A2, A3, A4, A5, A6, A7, A3New> Tuple7<A1, A2, A3, A4, A5, A6, A7>.mapA3(transform: (A3) -> A3New): Tuple7<A1, A2, A3New, A4, A5, A6, A7>

Maps Tuple7.a3 with the given transform function and returns a new Tuple7.

fun <A1, A2, A3, A4, A5, A6, A7, A8, A3New> Tuple8<A1, A2, A3, A4, A5, A6, A7, A8>.mapA3(transform: (A3) -> A3New): Tuple8<A1, A2, A3New, A4, A5, A6, A7, A8>

Maps Tuple8.a3 with the given transform function and returns a new Tuple8.

fun <A1, A2, A3, A4, A5, A6, A7, A8, A9, A3New> Tuple9<A1, A2, A3, A4, A5, A6, A7, A8, A9>.mapA3(transform: (A3) -> A3New): Tuple9<A1, A2, A3New, A4, A5, A6, A7, A8, A9>

Maps Tuple9.a3 with the given transform function and returns a new Tuple9.

mapA4

fun <A1, A2, A3, A4, A4New> Tuple4<A1, A2, A3, A4>.mapA4(transform: (A4) -> A4New): Tuple4<A1, A2, A3, A4New>

Maps Tuple4.a4 with the given transform function and returns a new Tuple4.

fun <A1, A2, A3, A4, A5, A4New> Tuple5<A1, A2, A3, A4, A5>.mapA4(transform: (A4) -> A4New): Tuple5<A1, A2, A3, A4New, A5>

Maps Tuple5.a4 with the given transform function and returns a new Tuple5.

fun <A1, A2, A3, A4, A5, A6, A4New> Tuple6<A1, A2, A3, A4, A5, A6>.mapA4(transform: (A4) -> A4New): Tuple6<A1, A2, A3, A4New, A5, A6>

Maps Tuple6.a4 with the given transform function and returns a new Tuple6.

fun <A1, A2, A3, A4, A5, A6, A7, A4New> Tuple7<A1, A2, A3, A4, A5, A6, A7>.mapA4(transform: (A4) -> A4New): Tuple7<A1, A2, A3, A4New, A5, A6, A7>

Maps Tuple7.a4 with the given transform function and returns a new Tuple7.

fun <A1, A2, A3, A4, A5, A6, A7, A8, A4New> Tuple8<A1, A2, A3, A4, A5, A6, A7, A8>.mapA4(transform: (A4) -> A4New): Tuple8<A1, A2, A3, A4New, A5, A6, A7, A8>

Maps Tuple8.a4 with the given transform function and returns a new Tuple8.

fun <A1, A2, A3, A4, A5, A6, A7, A8, A9, A4New> Tuple9<A1, A2, A3, A4, A5, A6, A7, A8, A9>.mapA4(transform: (A4) -> A4New): Tuple9<A1, A2, A3, A4New, A5, A6, A7, A8, A9>

Maps Tuple9.a4 with the given transform function and returns a new Tuple9.

mapA5

fun <A1, A2, A3, A4, A5, A5New> Tuple5<A1, A2, A3, A4, A5>.mapA5(transform: (A5) -> A5New): Tuple5<A1, A2, A3, A4, A5New>

Maps Tuple5.a5 with the given transform function and returns a new Tuple5.

fun <A1, A2, A3, A4, A5, A6, A5New> Tuple6<A1, A2, A3, A4, A5, A6>.mapA5(transform: (A5) -> A5New): Tuple6<A1, A2, A3, A4, A5New, A6>

Maps Tuple6.a5 with the given transform function and returns a new Tuple6.

fun <A1, A2, A3, A4, A5, A6, A7, A5New> Tuple7<A1, A2, A3, A4, A5, A6, A7>.mapA5(transform: (A5) -> A5New): Tuple7<A1, A2, A3, A4, A5New, A6, A7>

Maps Tuple7.a5 with the given transform function and returns a new Tuple7.

fun <A1, A2, A3, A4, A5, A6, A7, A8, A5New> Tuple8<A1, A2, A3, A4, A5, A6, A7, A8>.mapA5(transform: (A5) -> A5New): Tuple8<A1, A2, A3, A4, A5New, A6, A7, A8>

Maps Tuple8.a5 with the given transform function and returns a new Tuple8.

fun <A1, A2, A3, A4, A5, A6, A7, A8, A9, A5New> Tuple9<A1, A2, A3, A4, A5, A6, A7, A8, A9>.mapA5(transform: (A5) -> A5New): Tuple9<A1, A2, A3, A4, A5New, A6, A7, A8, A9>

Maps Tuple9.a5 with the given transform function and returns a new Tuple9.

mapA6

fun <A1, A2, A3, A4, A5, A6, A6New> Tuple6<A1, A2, A3, A4, A5, A6>.mapA6(transform: (A6) -> A6New): Tuple6<A1, A2, A3, A4, A5, A6New>

Maps Tuple6.a6 with the given transform function and returns a new Tuple6.

fun <A1, A2, A3, A4, A5, A6, A7, A6New> Tuple7<A1, A2, A3, A4, A5, A6, A7>.mapA6(transform: (A6) -> A6New): Tuple7<A1, A2, A3, A4, A5, A6New, A7>

Maps Tuple7.a6 with the given transform function and returns a new Tuple7.

fun <A1, A2, A3, A4, A5, A6, A7, A8, A6New> Tuple8<A1, A2, A3, A4, A5, A6, A7, A8>.mapA6(transform: (A6) -> A6New): Tuple8<A1, A2, A3, A4, A5, A6New, A7, A8>

Maps Tuple8.a6 with the given transform function and returns a new Tuple8.

fun <A1, A2, A3, A4, A5, A6, A7, A8, A9, A6New> Tuple9<A1, A2, A3, A4, A5, A6, A7, A8, A9>.mapA6(transform: (A6) -> A6New): Tuple9<A1, A2, A3, A4, A5, A6New, A7, A8, A9>

Maps Tuple9.a6 with the given transform function and returns a new Tuple9.

mapA7

fun <A1, A2, A3, A4, A5, A6, A7, A7New> Tuple7<A1, A2, A3, A4, A5, A6, A7>.mapA7(transform: (A7) -> A7New): Tuple7<A1, A2, A3, A4, A5, A6, A7New>

Maps Tuple7.a7 with the given transform function and returns a new Tuple7.

fun <A1, A2, A3, A4, A5, A6, A7, A8, A7New> Tuple8<A1, A2, A3, A4, A5, A6, A7, A8>.mapA7(transform: (A7) -> A7New): Tuple8<A1, A2, A3, A4, A5, A6, A7New, A8>

Maps Tuple8.a7 with the given transform function and returns a new Tuple8.

fun <A1, A2, A3, A4, A5, A6, A7, A8, A9, A7New> Tuple9<A1, A2, A3, A4, A5, A6, A7, A8, A9>.mapA7(transform: (A7) -> A7New): Tuple9<A1, A2, A3, A4, A5, A6, A7New, A8, A9>

Maps Tuple9.a7 with the given transform function and returns a new Tuple9.

mapA8

fun <A1, A2, A3, A4, A5, A6, A7, A8, A8New> Tuple8<A1, A2, A3, A4, A5, A6, A7, A8>.mapA8(transform: (A8) -> A8New): Tuple8<A1, A2, A3, A4, A5, A6, A7, A8New>

Maps Tuple8.a8 with the given transform function and returns a new Tuple8.

fun <A1, A2, A3, A4, A5, A6, A7, A8, A9, A8New> Tuple9<A1, A2, A3, A4, A5, A6, A7, A8, A9>.mapA8(transform: (A8) -> A8New): Tuple9<A1, A2, A3, A4, A5, A6, A7, A8New, A9>

Maps Tuple9.a8 with the given transform function and returns a new Tuple9.

mapA9

fun <A1, A2, A3, A4, A5, A6, A7, A8, A9, A9New> Tuple9<A1, A2, A3, A4, A5, A6, A7, A8, A9>.mapA9(transform: (A9) -> A9New): Tuple9<A1, A2, A3, A4, A5, A6, A7, A8, A9New>

Maps Tuple9.a9 with the given transform function and returns a new Tuple9.

mapFirst

fun <A1, A2, A1New> Pair<A1, A2>.mapFirst(transform: (A1) -> A1New): Pair<A1New, A2>

Maps Pair.first with the given transform function and returns a new Pair.

fun <A1, A2, A3, A1New> Triple<A1, A2, A3>.mapFirst(transform: (A1) -> A1New): Triple<A1New, A2, A3>

Maps Triple.first with the given transform function and returns a new Triple.

mapParents

fun <T> Map<T, T>.mapParents(child: T, failIfCyclic: Boolean = false): LinkedHashSet<T>

It is assumed that the Map represents a child parent relation where this function returns a LinkedHashSet with all collected parents.

mapRemaining

fun <T, R> Iterator<T>.mapRemaining(transform: (T) -> R): List<R>

Maps remaining values of this Iterator with the help of the given transform functions, returns an empty list if Iterator.hasNext returns false for the first call.

mapRemainingWithCounter

fun <T, R> Iterator<T>.mapRemainingWithCounter(transform: (index: Int, T) -> R): List<R>

Maps remaining values of this Iterator with the help of the given transform functions where a counter variable is passed ot the transform function starting by 0; returns an empty list if Iterator.hasNext returns false for the first call.

mapSecond

fun <A1, A2, A2New> Pair<A1, A2>.mapSecond(transform: (A2) -> A2New): Pair<A1, A2New>

Maps Pair.second with the given transform function and returns a new Pair.

fun <A1, A2, A3, A2New> Triple<A1, A2, A3>.mapSecond(transform: (A2) -> A2New): Triple<A1, A2New, A3>

Maps Triple.second with the given transform function and returns a new Triple.

mapThird

fun <A1, A2, A3, A3New> Triple<A1, A2, A3>.mapThird(transform: (A3) -> A3New): Triple<A1, A2, A3New>

Maps Triple.third with the given transform function and returns a new Triple.

mapVararg

inline fun <T, R> mapVararg(arg: T, otherArgs: Array<out T>, mapper: (T) -> R): Pair<R, Array<out R>>

@JvmName(name = "mapBooleanVararg")

inline fun <R> mapVararg(arg: Boolean, otherArgs: BooleanArray, mapper: (Boolean) -> R): Pair<R, Array<out R>>

@JvmName(name = "mapByteVararg")

inline fun <R> mapVararg(arg: Byte, otherArgs: ByteArray, mapper: (Byte) -> R): Pair<R, Array<out R>>

@JvmName(name = "mapCharVararg")

inline fun <R> mapVararg(arg: Char, otherArgs: CharArray, mapper: (Char) -> R): Pair<R, Array<out R>>

@JvmName(name = "mapDoubleVararg")

inline fun <R> mapVararg(arg: Double, otherArgs: DoubleArray, mapper: (Double) -> R): Pair<R, Array<out R>>

@JvmName(name = "mapFloatVararg")

inline fun <R> mapVararg(arg: Float, otherArgs: FloatArray, mapper: (Float) -> R): Pair<R, Array<out R>>

@JvmName(name = "mapIntVararg")

inline fun <R> mapVararg(arg: Int, otherArgs: IntArray, mapper: (Int) -> R): Pair<R, Array<out R>>

@JvmName(name = "mapLongVararg")

inline fun <R> mapVararg(arg: Long, otherArgs: LongArray, mapper: (Long) -> R): Pair<R, Array<out R>>

@JvmName(name = "mapShortVararg")

inline fun <R> mapVararg(arg: Short, otherArgs: ShortArray, mapper: (Short) -> R): Pair<R, Array<out R>>

Maps the given arg and all elements in otherArgs by the given mapper.

@JvmName(name = "mapVarargToBoolean")

inline fun <T> mapVararg(arg: T, otherArgs: Array<out T>, mapper: (T) -> Boolean): Pair<Boolean, BooleanArray>

@JvmName(name = "mapBooleanVarargToBoolean")

inline fun mapVararg(arg: Boolean, otherArgs: BooleanArray, mapper: (Boolean) -> Boolean): Pair<Boolean, BooleanArray>

@JvmName(name = "mapByteVarargToBoolean")

inline fun mapVararg(arg: Byte, otherArgs: ByteArray, mapper: (Byte) -> Boolean): Pair<Boolean, BooleanArray>

@JvmName(name = "mapCharVarargToBoolean")

inline fun mapVararg(arg: Char, otherArgs: CharArray, mapper: (Char) -> Boolean): Pair<Boolean, BooleanArray>

@JvmName(name = "mapDoubleVarargToBoolean")

inline fun mapVararg(arg: Double, otherArgs: DoubleArray, mapper: (Double) -> Boolean): Pair<Boolean, BooleanArray>

@JvmName(name = "mapFloatVarargToBoolean")

inline fun mapVararg(arg: Float, otherArgs: FloatArray, mapper: (Float) -> Boolean): Pair<Boolean, BooleanArray>

@JvmName(name = "mapIntVarargToBoolean")

inline fun mapVararg(arg: Int, otherArgs: IntArray, mapper: (Int) -> Boolean): Pair<Boolean, BooleanArray>

@JvmName(name = "mapLongVarargToBoolean")

inline fun mapVararg(arg: Long, otherArgs: LongArray, mapper: (Long) -> Boolean): Pair<Boolean, BooleanArray>

@JvmName(name = "mapShortVarargToBoolean")

inline fun mapVararg(arg: Short, otherArgs: ShortArray, mapper: (Short) -> Boolean): Pair<Boolean, BooleanArray>

Maps the given arg and all elements in otherArgs by the given mapper to Boolean.

@JvmName(name = "mapVarargToByte")

inline fun <T> mapVararg(arg: T, otherArgs: Array<out T>, mapper: (T) -> Byte): Pair<Byte, ByteArray>

@JvmName(name = "mapBooleanVarargToByte")

inline fun mapVararg(arg: Boolean, otherArgs: BooleanArray, mapper: (Boolean) -> Byte): Pair<Byte, ByteArray>

@JvmName(name = "mapByteVarargToByte")

inline fun mapVararg(arg: Byte, otherArgs: ByteArray, mapper: (Byte) -> Byte): Pair<Byte, ByteArray>

@JvmName(name = "mapCharVarargToByte")

inline fun mapVararg(arg: Char, otherArgs: CharArray, mapper: (Char) -> Byte): Pair<Byte, ByteArray>

@JvmName(name = "mapDoubleVarargToByte")

inline fun mapVararg(arg: Double, otherArgs: DoubleArray, mapper: (Double) -> Byte): Pair<Byte, ByteArray>

@JvmName(name = "mapFloatVarargToByte")

inline fun mapVararg(arg: Float, otherArgs: FloatArray, mapper: (Float) -> Byte): Pair<Byte, ByteArray>

@JvmName(name = "mapIntVarargToByte")

inline fun mapVararg(arg: Int, otherArgs: IntArray, mapper: (Int) -> Byte): Pair<Byte, ByteArray>

@JvmName(name = "mapLongVarargToByte")

inline fun mapVararg(arg: Long, otherArgs: LongArray, mapper: (Long) -> Byte): Pair<Byte, ByteArray>

@JvmName(name = "mapShortVarargToByte")

inline fun mapVararg(arg: Short, otherArgs: ShortArray, mapper: (Short) -> Byte): Pair<Byte, ByteArray>

Maps the given arg and all elements in otherArgs by the given mapper to Byte.

@JvmName(name = "mapVarargToChar")

inline fun <T> mapVararg(arg: T, otherArgs: Array<out T>, mapper: (T) -> Char): Pair<Char, CharArray>

@JvmName(name = "mapBooleanVarargToChar")

inline fun mapVararg(arg: Boolean, otherArgs: BooleanArray, mapper: (Boolean) -> Char): Pair<Char, CharArray>

@JvmName(name = "mapByteVarargToChar")

inline fun mapVararg(arg: Byte, otherArgs: ByteArray, mapper: (Byte) -> Char): Pair<Char, CharArray>

@JvmName(name = "mapCharVarargToChar")

inline fun mapVararg(arg: Char, otherArgs: CharArray, mapper: (Char) -> Char): Pair<Char, CharArray>

@JvmName(name = "mapDoubleVarargToChar")

inline fun mapVararg(arg: Double, otherArgs: DoubleArray, mapper: (Double) -> Char): Pair<Char, CharArray>

@JvmName(name = "mapFloatVarargToChar")

inline fun mapVararg(arg: Float, otherArgs: FloatArray, mapper: (Float) -> Char): Pair<Char, CharArray>

@JvmName(name = "mapIntVarargToChar")

inline fun mapVararg(arg: Int, otherArgs: IntArray, mapper: (Int) -> Char): Pair<Char, CharArray>

@JvmName(name = "mapLongVarargToChar")

inline fun mapVararg(arg: Long, otherArgs: LongArray, mapper: (Long) -> Char): Pair<Char, CharArray>

@JvmName(name = "mapShortVarargToChar")

inline fun mapVararg(arg: Short, otherArgs: ShortArray, mapper: (Short) -> Char): Pair<Char, CharArray>

Maps the given arg and all elements in otherArgs by the given mapper to Char.

@JvmName(name = "mapVarargToDouble")

inline fun <T> mapVararg(arg: T, otherArgs: Array<out T>, mapper: (T) -> Double): Pair<Double, DoubleArray>

@JvmName(name = "mapBooleanVarargToDouble")

inline fun mapVararg(arg: Boolean, otherArgs: BooleanArray, mapper: (Boolean) -> Double): Pair<Double, DoubleArray>

@JvmName(name = "mapByteVarargToDouble")

inline fun mapVararg(arg: Byte, otherArgs: ByteArray, mapper: (Byte) -> Double): Pair<Double, DoubleArray>

@JvmName(name = "mapCharVarargToDouble")

inline fun mapVararg(arg: Char, otherArgs: CharArray, mapper: (Char) -> Double): Pair<Double, DoubleArray>

@JvmName(name = "mapDoubleVarargToDouble")

inline fun mapVararg(arg: Double, otherArgs: DoubleArray, mapper: (Double) -> Double): Pair<Double, DoubleArray>

@JvmName(name = "mapFloatVarargToDouble")

inline fun mapVararg(arg: Float, otherArgs: FloatArray, mapper: (Float) -> Double): Pair<Double, DoubleArray>

@JvmName(name = "mapIntVarargToDouble")

inline fun mapVararg(arg: Int, otherArgs: IntArray, mapper: (Int) -> Double): Pair<Double, DoubleArray>

@JvmName(name = "mapLongVarargToDouble")

inline fun mapVararg(arg: Long, otherArgs: LongArray, mapper: (Long) -> Double): Pair<Double, DoubleArray>

@JvmName(name = "mapShortVarargToDouble")

inline fun mapVararg(arg: Short, otherArgs: ShortArray, mapper: (Short) -> Double): Pair<Double, DoubleArray>

Maps the given arg and all elements in otherArgs by the given mapper to Double.

@JvmName(name = "mapVarargToFloat")

inline fun <T> mapVararg(arg: T, otherArgs: Array<out T>, mapper: (T) -> Float): Pair<Float, FloatArray>

@JvmName(name = "mapBooleanVarargToFloat")

inline fun mapVararg(arg: Boolean, otherArgs: BooleanArray, mapper: (Boolean) -> Float): Pair<Float, FloatArray>

@JvmName(name = "mapByteVarargToFloat")

inline fun mapVararg(arg: Byte, otherArgs: ByteArray, mapper: (Byte) -> Float): Pair<Float, FloatArray>

@JvmName(name = "mapCharVarargToFloat")

inline fun mapVararg(arg: Char, otherArgs: CharArray, mapper: (Char) -> Float): Pair<Float, FloatArray>

@JvmName(name = "mapDoubleVarargToFloat")

inline fun mapVararg(arg: Double, otherArgs: DoubleArray, mapper: (Double) -> Float): Pair<Float, FloatArray>

@JvmName(name = "mapFloatVarargToFloat")

inline fun mapVararg(arg: Float, otherArgs: FloatArray, mapper: (Float) -> Float): Pair<Float, FloatArray>

@JvmName(name = "mapIntVarargToFloat")

inline fun mapVararg(arg: Int, otherArgs: IntArray, mapper: (Int) -> Float): Pair<Float, FloatArray>

@JvmName(name = "mapLongVarargToFloat")

inline fun mapVararg(arg: Long, otherArgs: LongArray, mapper: (Long) -> Float): Pair<Float, FloatArray>

@JvmName(name = "mapShortVarargToFloat")

inline fun mapVararg(arg: Short, otherArgs: ShortArray, mapper: (Short) -> Float): Pair<Float, FloatArray>

Maps the given arg and all elements in otherArgs by the given mapper to Float.

@JvmName(name = "mapVarargToInt")

inline fun <T> mapVararg(arg: T, otherArgs: Array<out T>, mapper: (T) -> Int): Pair<Int, IntArray>

@JvmName(name = "mapBooleanVarargToInt")

inline fun mapVararg(arg: Boolean, otherArgs: BooleanArray, mapper: (Boolean) -> Int): Pair<Int, IntArray>

@JvmName(name = "mapByteVarargToInt")

inline fun mapVararg(arg: Byte, otherArgs: ByteArray, mapper: (Byte) -> Int): Pair<Int, IntArray>

@JvmName(name = "mapCharVarargToInt")

inline fun mapVararg(arg: Char, otherArgs: CharArray, mapper: (Char) -> Int): Pair<Int, IntArray>

@JvmName(name = "mapDoubleVarargToInt")

inline fun mapVararg(arg: Double, otherArgs: DoubleArray, mapper: (Double) -> Int): Pair<Int, IntArray>

@JvmName(name = "mapFloatVarargToInt")

inline fun mapVararg(arg: Float, otherArgs: FloatArray, mapper: (Float) -> Int): Pair<Int, IntArray>

@JvmName(name = "mapIntVarargToInt")

inline fun mapVararg(arg: Int, otherArgs: IntArray, mapper: (Int) -> Int): Pair<Int, IntArray>

@JvmName(name = "mapLongVarargToInt")

inline fun mapVararg(arg: Long, otherArgs: LongArray, mapper: (Long) -> Int): Pair<Int, IntArray>

@JvmName(name = "mapShortVarargToInt")

inline fun mapVararg(arg: Short, otherArgs: ShortArray, mapper: (Short) -> Int): Pair<Int, IntArray>

Maps the given arg and all elements in otherArgs by the given mapper to Int.

@JvmName(name = "mapVarargToLong")

inline fun <T> mapVararg(arg: T, otherArgs: Array<out T>, mapper: (T) -> Long): Pair<Long, LongArray>

@JvmName(name = "mapBooleanVarargToLong")

inline fun mapVararg(arg: Boolean, otherArgs: BooleanArray, mapper: (Boolean) -> Long): Pair<Long, LongArray>

@JvmName(name = "mapByteVarargToLong")

inline fun mapVararg(arg: Byte, otherArgs: ByteArray, mapper: (Byte) -> Long): Pair<Long, LongArray>

@JvmName(name = "mapCharVarargToLong")

inline fun mapVararg(arg: Char, otherArgs: CharArray, mapper: (Char) -> Long): Pair<Long, LongArray>

@JvmName(name = "mapDoubleVarargToLong")

inline fun mapVararg(arg: Double, otherArgs: DoubleArray, mapper: (Double) -> Long): Pair<Long, LongArray>

@JvmName(name = "mapFloatVarargToLong")

inline fun mapVararg(arg: Float, otherArgs: FloatArray, mapper: (Float) -> Long): Pair<Long, LongArray>

@JvmName(name = "mapIntVarargToLong")

inline fun mapVararg(arg: Int, otherArgs: IntArray, mapper: (Int) -> Long): Pair<Long, LongArray>

@JvmName(name = "mapLongVarargToLong")

inline fun mapVararg(arg: Long, otherArgs: LongArray, mapper: (Long) -> Long): Pair<Long, LongArray>

@JvmName(name = "mapShortVarargToLong")

inline fun mapVararg(arg: Short, otherArgs: ShortArray, mapper: (Short) -> Long): Pair<Long, LongArray>

Maps the given arg and all elements in otherArgs by the given mapper to Long.

@JvmName(name = "mapVarargToShort")

inline fun <T> mapVararg(arg: T, otherArgs: Array<out T>, mapper: (T) -> Short): Pair<Short, ShortArray>

@JvmName(name = "mapBooleanVarargToShort")

inline fun mapVararg(arg: Boolean, otherArgs: BooleanArray, mapper: (Boolean) -> Short): Pair<Short, ShortArray>

@JvmName(name = "mapByteVarargToShort")

inline fun mapVararg(arg: Byte, otherArgs: ByteArray, mapper: (Byte) -> Short): Pair<Short, ShortArray>

@JvmName(name = "mapCharVarargToShort")

inline fun mapVararg(arg: Char, otherArgs: CharArray, mapper: (Char) -> Short): Pair<Short, ShortArray>

@JvmName(name = "mapDoubleVarargToShort")

inline fun mapVararg(arg: Double, otherArgs: DoubleArray, mapper: (Double) -> Short): Pair<Short, ShortArray>

@JvmName(name = "mapFloatVarargToShort")

inline fun mapVararg(arg: Float, otherArgs: FloatArray, mapper: (Float) -> Short): Pair<Short, ShortArray>

@JvmName(name = "mapIntVarargToShort")

inline fun mapVararg(arg: Int, otherArgs: IntArray, mapper: (Int) -> Short): Pair<Short, ShortArray>

@JvmName(name = "mapLongVarargToShort")

inline fun mapVararg(arg: Long, otherArgs: LongArray, mapper: (Long) -> Short): Pair<Short, ShortArray>

@JvmName(name = "mapShortVarargToShort")

inline fun mapVararg(arg: Short, otherArgs: ShortArray, mapper: (Short) -> Short): Pair<Short, ShortArray>

Maps the given arg and all elements in otherArgs by the given mapper to Short.

mapVarargIndexed

inline fun <T, R> mapVarargIndexed(arg: T, otherArgs: Array<out T>, mapper: (Int, T) -> R): Pair<R, Array<out R>>

@JvmName(name = "mapBooleanVarargIndexed")

inline fun <R> mapVarargIndexed(arg: Boolean, otherArgs: BooleanArray, mapper: (Int, Boolean) -> R): Pair<R, Array<out R>>

@JvmName(name = "mapByteVarargIndexed")

inline fun <R> mapVarargIndexed(arg: Byte, otherArgs: ByteArray, mapper: (Int, Byte) -> R): Pair<R, Array<out R>>

@JvmName(name = "mapCharVarargIndexed")

inline fun <R> mapVarargIndexed(arg: Char, otherArgs: CharArray, mapper: (Int, Char) -> R): Pair<R, Array<out R>>

@JvmName(name = "mapDoubleVarargIndexed")

inline fun <R> mapVarargIndexed(arg: Double, otherArgs: DoubleArray, mapper: (Int, Double) -> R): Pair<R, Array<out R>>

@JvmName(name = "mapFloatVarargIndexed")

inline fun <R> mapVarargIndexed(arg: Float, otherArgs: FloatArray, mapper: (Int, Float) -> R): Pair<R, Array<out R>>

@JvmName(name = "mapIntVarargIndexed")

inline fun <R> mapVarargIndexed(arg: Int, otherArgs: IntArray, mapper: (Int, Int) -> R): Pair<R, Array<out R>>

@JvmName(name = "mapLongVarargIndexed")

inline fun <R> mapVarargIndexed(arg: Long, otherArgs: LongArray, mapper: (Int, Long) -> R): Pair<R, Array<out R>>

@JvmName(name = "mapShortVarargIndexed")

inline fun <R> mapVarargIndexed(arg: Short, otherArgs: ShortArray, mapper: (Int, Short) -> R): Pair<R, Array<out R>>

Maps the given arg and all elements in otherArgs by the given mapper.

@JvmName(name = "mapVarargIndexedToBoolean")

inline fun <T> mapVarargIndexed(arg: T, otherArgs: Array<out T>, mapper: (Int, T) -> Boolean): Pair<Boolean, BooleanArray>

@JvmName(name = "mapBooleanVarargIndexedToBoolean")

inline fun mapVarargIndexed(arg: Boolean, otherArgs: BooleanArray, mapper: (Int, Boolean) -> Boolean): Pair<Boolean, BooleanArray>

@JvmName(name = "mapByteVarargIndexedToBoolean")

inline fun mapVarargIndexed(arg: Byte, otherArgs: ByteArray, mapper: (Int, Byte) -> Boolean): Pair<Boolean, BooleanArray>

@JvmName(name = "mapCharVarargIndexedToBoolean")

inline fun mapVarargIndexed(arg: Char, otherArgs: CharArray, mapper: (Int, Char) -> Boolean): Pair<Boolean, BooleanArray>

@JvmName(name = "mapDoubleVarargIndexedToBoolean")

inline fun mapVarargIndexed(arg: Double, otherArgs: DoubleArray, mapper: (Int, Double) -> Boolean): Pair<Boolean, BooleanArray>

@JvmName(name = "mapFloatVarargIndexedToBoolean")

inline fun mapVarargIndexed(arg: Float, otherArgs: FloatArray, mapper: (Int, Float) -> Boolean): Pair<Boolean, BooleanArray>

@JvmName(name = "mapIntVarargIndexedToBoolean")

inline fun mapVarargIndexed(arg: Int, otherArgs: IntArray, mapper: (Int, Int) -> Boolean): Pair<Boolean, BooleanArray>

@JvmName(name = "mapLongVarargIndexedToBoolean")

inline fun mapVarargIndexed(arg: Long, otherArgs: LongArray, mapper: (Int, Long) -> Boolean): Pair<Boolean, BooleanArray>

@JvmName(name = "mapShortVarargIndexedToBoolean")

inline fun mapVarargIndexed(arg: Short, otherArgs: ShortArray, mapper: (Int, Short) -> Boolean): Pair<Boolean, BooleanArray>

Maps the given arg and all elements in otherArgs by the given mapper to Boolean.

@JvmName(name = "mapVarargIndexedToByte")

inline fun <T> mapVarargIndexed(arg: T, otherArgs: Array<out T>, mapper: (Int, T) -> Byte): Pair<Byte, ByteArray>

@JvmName(name = "mapBooleanVarargIndexedToByte")

inline fun mapVarargIndexed(arg: Boolean, otherArgs: BooleanArray, mapper: (Int, Boolean) -> Byte): Pair<Byte, ByteArray>

@JvmName(name = "mapByteVarargIndexedToByte")

inline fun mapVarargIndexed(arg: Byte, otherArgs: ByteArray, mapper: (Int, Byte) -> Byte): Pair<Byte, ByteArray>

@JvmName(name = "mapCharVarargIndexedToByte")

inline fun mapVarargIndexed(arg: Char, otherArgs: CharArray, mapper: (Int, Char) -> Byte): Pair<Byte, ByteArray>

@JvmName(name = "mapDoubleVarargIndexedToByte")

inline fun mapVarargIndexed(arg: Double, otherArgs: DoubleArray, mapper: (Int, Double) -> Byte): Pair<Byte, ByteArray>

@JvmName(name = "mapFloatVarargIndexedToByte")

inline fun mapVarargIndexed(arg: Float, otherArgs: FloatArray, mapper: (Int, Float) -> Byte): Pair<Byte, ByteArray>

@JvmName(name = "mapIntVarargIndexedToByte")

inline fun mapVarargIndexed(arg: Int, otherArgs: IntArray, mapper: (Int, Int) -> Byte): Pair<Byte, ByteArray>

@JvmName(name = "mapLongVarargIndexedToByte")

inline fun mapVarargIndexed(arg: Long, otherArgs: LongArray, mapper: (Int, Long) -> Byte): Pair<Byte, ByteArray>

@JvmName(name = "mapShortVarargIndexedToByte")

inline fun mapVarargIndexed(arg: Short, otherArgs: ShortArray, mapper: (Int, Short) -> Byte): Pair<Byte, ByteArray>

Maps the given arg and all elements in otherArgs by the given mapper to Byte.

@JvmName(name = "mapVarargIndexedToChar")

inline fun <T> mapVarargIndexed(arg: T, otherArgs: Array<out T>, mapper: (Int, T) -> Char): Pair<Char, CharArray>

@JvmName(name = "mapBooleanVarargIndexedToChar")

inline fun mapVarargIndexed(arg: Boolean, otherArgs: BooleanArray, mapper: (Int, Boolean) -> Char): Pair<Char, CharArray>

@JvmName(name = "mapByteVarargIndexedToChar")

inline fun mapVarargIndexed(arg: Byte, otherArgs: ByteArray, mapper: (Int, Byte) -> Char): Pair<Char, CharArray>

@JvmName(name = "mapCharVarargIndexedToChar")

inline fun mapVarargIndexed(arg: Char, otherArgs: CharArray, mapper: (Int, Char) -> Char): Pair<Char, CharArray>

@JvmName(name = "mapDoubleVarargIndexedToChar")

inline fun mapVarargIndexed(arg: Double, otherArgs: DoubleArray, mapper: (Int, Double) -> Char): Pair<Char, CharArray>

@JvmName(name = "mapFloatVarargIndexedToChar")

inline fun mapVarargIndexed(arg: Float, otherArgs: FloatArray, mapper: (Int, Float) -> Char): Pair<Char, CharArray>

@JvmName(name = "mapIntVarargIndexedToChar")

inline fun mapVarargIndexed(arg: Int, otherArgs: IntArray, mapper: (Int, Int) -> Char): Pair<Char, CharArray>

@JvmName(name = "mapLongVarargIndexedToChar")

inline fun mapVarargIndexed(arg: Long, otherArgs: LongArray, mapper: (Int, Long) -> Char): Pair<Char, CharArray>

@JvmName(name = "mapShortVarargIndexedToChar")

inline fun mapVarargIndexed(arg: Short, otherArgs: ShortArray, mapper: (Int, Short) -> Char): Pair<Char, CharArray>

Maps the given arg and all elements in otherArgs by the given mapper to Char.

@JvmName(name = "mapVarargIndexedToDouble")

inline fun <T> mapVarargIndexed(arg: T, otherArgs: Array<out T>, mapper: (Int, T) -> Double): Pair<Double, DoubleArray>

@JvmName(name = "mapBooleanVarargIndexedToDouble")

inline fun mapVarargIndexed(arg: Boolean, otherArgs: BooleanArray, mapper: (Int, Boolean) -> Double): Pair<Double, DoubleArray>

@JvmName(name = "mapByteVarargIndexedToDouble")

inline fun mapVarargIndexed(arg: Byte, otherArgs: ByteArray, mapper: (Int, Byte) -> Double): Pair<Double, DoubleArray>

@JvmName(name = "mapCharVarargIndexedToDouble")

inline fun mapVarargIndexed(arg: Char, otherArgs: CharArray, mapper: (Int, Char) -> Double): Pair<Double, DoubleArray>

@JvmName(name = "mapDoubleVarargIndexedToDouble")

inline fun mapVarargIndexed(arg: Double, otherArgs: DoubleArray, mapper: (Int, Double) -> Double): Pair<Double, DoubleArray>

@JvmName(name = "mapFloatVarargIndexedToDouble")

inline fun mapVarargIndexed(arg: Float, otherArgs: FloatArray, mapper: (Int, Float) -> Double): Pair<Double, DoubleArray>

@JvmName(name = "mapIntVarargIndexedToDouble")

inline fun mapVarargIndexed(arg: Int, otherArgs: IntArray, mapper: (Int, Int) -> Double): Pair<Double, DoubleArray>

@JvmName(name = "mapLongVarargIndexedToDouble")

inline fun mapVarargIndexed(arg: Long, otherArgs: LongArray, mapper: (Int, Long) -> Double): Pair<Double, DoubleArray>

@JvmName(name = "mapShortVarargIndexedToDouble")

inline fun mapVarargIndexed(arg: Short, otherArgs: ShortArray, mapper: (Int, Short) -> Double): Pair<Double, DoubleArray>

Maps the given arg and all elements in otherArgs by the given mapper to Double.

@JvmName(name = "mapVarargIndexedToFloat")

inline fun <T> mapVarargIndexed(arg: T, otherArgs: Array<out T>, mapper: (Int, T) -> Float): Pair<Float, FloatArray>

@JvmName(name = "mapBooleanVarargIndexedToFloat")

inline fun mapVarargIndexed(arg: Boolean, otherArgs: BooleanArray, mapper: (Int, Boolean) -> Float): Pair<Float, FloatArray>

@JvmName(name = "mapByteVarargIndexedToFloat")

inline fun mapVarargIndexed(arg: Byte, otherArgs: ByteArray, mapper: (Int, Byte) -> Float): Pair<Float, FloatArray>

@JvmName(name = "mapCharVarargIndexedToFloat")

inline fun mapVarargIndexed(arg: Char, otherArgs: CharArray, mapper: (Int, Char) -> Float): Pair<Float, FloatArray>

@JvmName(name = "mapDoubleVarargIndexedToFloat")

inline fun mapVarargIndexed(arg: Double, otherArgs: DoubleArray, mapper: (Int, Double) -> Float): Pair<Float, FloatArray>

@JvmName(name = "mapFloatVarargIndexedToFloat")

inline fun mapVarargIndexed(arg: Float, otherArgs: FloatArray, mapper: (Int, Float) -> Float): Pair<Float, FloatArray>

@JvmName(name = "mapIntVarargIndexedToFloat")

inline fun mapVarargIndexed(arg: Int, otherArgs: IntArray, mapper: (Int, Int) -> Float): Pair<Float, FloatArray>

@JvmName(name = "mapLongVarargIndexedToFloat")

inline fun mapVarargIndexed(arg: Long, otherArgs: LongArray, mapper: (Int, Long) -> Float): Pair<Float, FloatArray>

@JvmName(name = "mapShortVarargIndexedToFloat")

inline fun mapVarargIndexed(arg: Short, otherArgs: ShortArray, mapper: (Int, Short) -> Float): Pair<Float, FloatArray>

Maps the given arg and all elements in otherArgs by the given mapper to Float.

@JvmName(name = "mapVarargIndexedToInt")

inline fun <T> mapVarargIndexed(arg: T, otherArgs: Array<out T>, mapper: (Int, T) -> Int): Pair<Int, IntArray>

@JvmName(name = "mapBooleanVarargIndexedToInt")

inline fun mapVarargIndexed(arg: Boolean, otherArgs: BooleanArray, mapper: (Int, Boolean) -> Int): Pair<Int, IntArray>

@JvmName(name = "mapByteVarargIndexedToInt")

inline fun mapVarargIndexed(arg: Byte, otherArgs: ByteArray, mapper: (Int, Byte) -> Int): Pair<Int, IntArray>

@JvmName(name = "mapCharVarargIndexedToInt")

inline fun mapVarargIndexed(arg: Char, otherArgs: CharArray, mapper: (Int, Char) -> Int): Pair<Int, IntArray>

@JvmName(name = "mapDoubleVarargIndexedToInt")

inline fun mapVarargIndexed(arg: Double, otherArgs: DoubleArray, mapper: (Int, Double) -> Int): Pair<Int, IntArray>

@JvmName(name = "mapFloatVarargIndexedToInt")

inline fun mapVarargIndexed(arg: Float, otherArgs: FloatArray, mapper: (Int, Float) -> Int): Pair<Int, IntArray>

@JvmName(name = "mapIntVarargIndexedToInt")

inline fun mapVarargIndexed(arg: Int, otherArgs: IntArray, mapper: (Int, Int) -> Int): Pair<Int, IntArray>

@JvmName(name = "mapLongVarargIndexedToInt")

inline fun mapVarargIndexed(arg: Long, otherArgs: LongArray, mapper: (Int, Long) -> Int): Pair<Int, IntArray>

@JvmName(name = "mapShortVarargIndexedToInt")

inline fun mapVarargIndexed(arg: Short, otherArgs: ShortArray, mapper: (Int, Short) -> Int): Pair<Int, IntArray>

Maps the given arg and all elements in otherArgs by the given mapper to Int.

@JvmName(name = "mapVarargIndexedToLong")

inline fun <T> mapVarargIndexed(arg: T, otherArgs: Array<out T>, mapper: (Int, T) -> Long): Pair<Long, LongArray>

@JvmName(name = "mapBooleanVarargIndexedToLong")

inline fun mapVarargIndexed(arg: Boolean, otherArgs: BooleanArray, mapper: (Int, Boolean) -> Long): Pair<Long, LongArray>

@JvmName(name = "mapByteVarargIndexedToLong")

inline fun mapVarargIndexed(arg: Byte, otherArgs: ByteArray, mapper: (Int, Byte) -> Long): Pair<Long, LongArray>

@JvmName(name = "mapCharVarargIndexedToLong")

inline fun mapVarargIndexed(arg: Char, otherArgs: CharArray, mapper: (Int, Char) -> Long): Pair<Long, LongArray>

@JvmName(name = "mapDoubleVarargIndexedToLong")

inline fun mapVarargIndexed(arg: Double, otherArgs: DoubleArray, mapper: (Int, Double) -> Long): Pair<Long, LongArray>

@JvmName(name = "mapFloatVarargIndexedToLong")

inline fun mapVarargIndexed(arg: Float, otherArgs: FloatArray, mapper: (Int, Float) -> Long): Pair<Long, LongArray>

@JvmName(name = "mapIntVarargIndexedToLong")

inline fun mapVarargIndexed(arg: Int, otherArgs: IntArray, mapper: (Int, Int) -> Long): Pair<Long, LongArray>

@JvmName(name = "mapLongVarargIndexedToLong")

inline fun mapVarargIndexed(arg: Long, otherArgs: LongArray, mapper: (Int, Long) -> Long): Pair<Long, LongArray>

@JvmName(name = "mapShortVarargIndexedToLong")

inline fun mapVarargIndexed(arg: Short, otherArgs: ShortArray, mapper: (Int, Short) -> Long): Pair<Long, LongArray>

Maps the given arg and all elements in otherArgs by the given mapper to Long.

@JvmName(name = "mapVarargIndexedToShort")

inline fun <T> mapVarargIndexed(arg: T, otherArgs: Array<out T>, mapper: (Int, T) -> Short): Pair<Short, ShortArray>

@JvmName(name = "mapBooleanVarargIndexedToShort")

inline fun mapVarargIndexed(arg: Boolean, otherArgs: BooleanArray, mapper: (Int, Boolean) -> Short): Pair<Short, ShortArray>

@JvmName(name = "mapByteVarargIndexedToShort")

inline fun mapVarargIndexed(arg: Byte, otherArgs: ByteArray, mapper: (Int, Byte) -> Short): Pair<Short, ShortArray>

@JvmName(name = "mapCharVarargIndexedToShort")

inline fun mapVarargIndexed(arg: Char, otherArgs: CharArray, mapper: (Int, Char) -> Short): Pair<Short, ShortArray>

@JvmName(name = "mapDoubleVarargIndexedToShort")

inline fun mapVarargIndexed(arg: Double, otherArgs: DoubleArray, mapper: (Int, Double) -> Short): Pair<Short, ShortArray>

@JvmName(name = "mapFloatVarargIndexedToShort")

inline fun mapVarargIndexed(arg: Float, otherArgs: FloatArray, mapper: (Int, Float) -> Short): Pair<Short, ShortArray>

@JvmName(name = "mapIntVarargIndexedToShort")

inline fun mapVarargIndexed(arg: Int, otherArgs: IntArray, mapper: (Int, Int) -> Short): Pair<Short, ShortArray>

@JvmName(name = "mapLongVarargIndexedToShort")

inline fun mapVarargIndexed(arg: Long, otherArgs: LongArray, mapper: (Int, Long) -> Short): Pair<Short, ShortArray>

@JvmName(name = "mapShortVarargIndexedToShort")

inline fun mapVarargIndexed(arg: Short, otherArgs: ShortArray, mapper: (Int, Short) -> Short): Pair<Short, ShortArray>

Maps the given arg and all elements in otherArgs by the given mapper to Short.

takeIf

inline fun <R> takeIf(predicate: Boolean, provider: () -> R): R?

Calls the provider only if the predicate holds, returns null otherwise.

toList

fun <T> Tuple4<T, T, T, T>.toList(): List<T>

Converts this Tuple4 into a List.

fun <T> Tuple5<T, T, T, T, T>.toList(): List<T>

Converts this Tuple5 into a List.

fun <T> Tuple6<T, T, T, T, T, T>.toList(): List<T>

Converts this Tuple6 into a List.

fun <T> Tuple7<T, T, T, T, T, T, T>.toList(): List<T>

Converts this Tuple7 into a List.

fun <T> Tuple8<T, T, T, T, T, T, T, T>.toList(): List<T>

Converts this Tuple8 into a List.

fun <T> Tuple9<T, T, T, T, T, T, T, T, T>.toList(): List<T>

Converts this Tuple9 into a List.

toPeekingIterator

fun <T : Any> Iterator<T>.toPeekingIterator(): PeekingIterator<T>

Wraps this Iterator into a PeekingIterator and returns it.

toSequence

fun <T> Tuple4<T, T, T, T>.toSequence(): Sequence<T>

Converts this Tuple4 into a Sequence.

fun <T> Tuple5<T, T, T, T, T>.toSequence(): Sequence<T>

Converts this Tuple5 into a Sequence.

fun <T> Tuple6<T, T, T, T, T, T>.toSequence(): Sequence<T>

Converts this Tuple6 into a Sequence.

fun <T> Tuple7<T, T, T, T, T, T, T>.toSequence(): Sequence<T>

Converts this Tuple7 into a Sequence.

fun <T> Tuple8<T, T, T, T, T, T, T, T>.toSequence(): Sequence<T>

Converts this Tuple8 into a Sequence.

fun <T> Tuple9<T, T, T, T, T, T, T, T, T>.toSequence(): Sequence<T>

Converts this Tuple9 into a Sequence.

fun <T> Pair<T, T>.toSequence(): Sequence<T>

Converts this Pair into a Sequence.

fun <T> Triple<T, T, T>.toSequence(): Sequence<T>

Converts this Triple into a Sequence.

toVararg

inline fun <T> Array<out T>.toVararg(): Pair<T, Array<out T>>

Splits this Array into the first element and the rest as Array<out T>.

fun Array<Boolean>.toVararg(): Pair<Boolean, BooleanArray>

Splits this Array into the first element and the rest as BooleanArray.

fun Array<Byte>.toVararg(): Pair<Byte, ByteArray>

Splits this Array into the first element and the rest as ByteArray.

fun Array<Char>.toVararg(): Pair<Char, CharArray>

Splits this Array into the first element and the rest as CharArray.

fun Array<Double>.toVararg(): Pair<Double, DoubleArray>

Splits this Array into the first element and the rest as DoubleArray.

fun Array<Float>.toVararg(): Pair<Float, FloatArray>

Splits this Array into the first element and the rest as FloatArray.

fun Array<Int>.toVararg(): Pair<Int, IntArray>

Splits this Array into the first element and the rest as IntArray.

fun Array<Long>.toVararg(): Pair<Long, LongArray>

Splits this Array into the first element and the rest as LongArray.

fun Array<Short>.toVararg(): Pair<Short, ShortArray>

Splits this Array into the first element and the rest as ShortArray.

fun BooleanArray.toVararg(): Pair<Boolean, BooleanArray>

Splits this BooleanArray into the first element and the rest as BooleanArray.

fun ByteArray.toVararg(): Pair<Byte, ByteArray>

Splits this ByteArray into the first element and the rest as ByteArray.

fun CharArray.toVararg(): Pair<Char, CharArray>

Splits this CharArray into the first element and the rest as CharArray.

fun DoubleArray.toVararg(): Pair<Double, DoubleArray>

Splits this DoubleArray into the first element and the rest as DoubleArray.

fun FloatArray.toVararg(): Pair<Float, FloatArray>

Splits this FloatArray into the first element and the rest as FloatArray.

fun IntArray.toVararg(): Pair<Int, IntArray>

Splits this IntArray into the first element and the rest as IntArray.

fun LongArray.toVararg(): Pair<Long, LongArray>

Splits this LongArray into the first element and the rest as LongArray.

fun ShortArray.toVararg(): Pair<Short, ShortArray>

Splits this ShortArray into the first element and the rest as ShortArray.

inline fun <T> Iterable<T>.toVararg(): Pair<T, Array<out T>>

Splits this Iterable into the first element and the rest as Array<out T>.

@JvmName(name = "toVarargBoolean")

fun Iterable<Boolean>.toVararg(): Pair<Boolean, BooleanArray>

Splits this Iterable into the first element and the rest as BooleanArray.

@JvmName(name = "toVarargByte")

fun Iterable<Byte>.toVararg(): Pair<Byte, ByteArray>

Splits this Iterable into the first element and the rest as ByteArray.

@JvmName(name = "toVarargChar")

fun Iterable<Char>.toVararg(): Pair<Char, CharArray>

Splits this Iterable into the first element and the rest as CharArray.

@JvmName(name = "toVarargDouble")

fun Iterable<Double>.toVararg(): Pair<Double, DoubleArray>

Splits this Iterable into the first element and the rest as DoubleArray.

@JvmName(name = "toVarargFloat")

fun Iterable<Float>.toVararg(): Pair<Float, FloatArray>

Splits this Iterable into the first element and the rest as FloatArray.

@JvmName(name = "toVarargInt")

fun Iterable<Int>.toVararg(): Pair<Int, IntArray>

Splits this Iterable into the first element and the rest as IntArray.

@JvmName(name = "toVarargLong")

fun Iterable<Long>.toVararg(): Pair<Long, LongArray>

Splits this Iterable into the first element and the rest as LongArray.

@JvmName(name = "toVarargShort")

fun Iterable<Short>.toVararg(): Pair<Short, ShortArray>

Splits this Iterable into the first element and the rest as ShortArray.

inline fun <T> Sequence<T>.toVararg(): Pair<T, Array<out T>>

Splits this Sequence into the first element and the rest as Array<out T>.

@JvmName(name = "toVarargBoolean")

fun Sequence<Boolean>.toVararg(): Pair<Boolean, BooleanArray>

Splits this Sequence into the first element and the rest as BooleanArray.

@JvmName(name = "toVarargByte")

fun Sequence<Byte>.toVararg(): Pair<Byte, ByteArray>

Splits this Sequence into the first element and the rest as ByteArray.

@JvmName(name = "toVarargChar")

fun Sequence<Char>.toVararg(): Pair<Char, CharArray>

Splits this Sequence into the first element and the rest as CharArray.

@JvmName(name = "toVarargDouble")

fun Sequence<Double>.toVararg(): Pair<Double, DoubleArray>

Splits this Sequence into the first element and the rest as DoubleArray.

@JvmName(name = "toVarargFloat")

fun Sequence<Float>.toVararg(): Pair<Float, FloatArray>

Splits this Sequence into the first element and the rest as FloatArray.

@JvmName(name = "toVarargInt")

fun Sequence<Int>.toVararg(): Pair<Int, IntArray>

Splits this Sequence into the first element and the rest as IntArray.

@JvmName(name = "toVarargLong")

fun Sequence<Long>.toVararg(): Pair<Long, LongArray>

Splits this Sequence into the first element and the rest as LongArray.

@JvmName(name = "toVarargShort")

fun Sequence<Short>.toVararg(): Pair<Short, ShortArray>

Splits this Sequence into the first element and the rest as ShortArray.

Tuple

fun <A1, A2> Tuple(a1: A1, a2: A2): Pair<A1, A2>

Factory method to create a Pair.

fun <A1, A2, A3> Tuple(a1: A1, a2: A2, a3: A3): Triple<A1, A2, A3>

Factory method to create a Triple.

fun <A1, A2, A3, A4> Tuple(a1: A1, a2: A2, a3: A3, a4: A4): Tuple4<A1, A2, A3, A4>

Factory method to create a Tuple4.

fun <A1, A2, A3, A4, A5> Tuple(a1: A1, a2: A2, a3: A3, a4: A4, a5: A5): Tuple5<A1, A2, A3, A4, A5>

Factory method to create a Tuple5.

fun <A1, A2, A3, A4, A5, A6> Tuple(a1: A1, a2: A2, a3: A3, a4: A4, a5: A5, a6: A6): Tuple6<A1, A2, A3, A4, A5, A6>

Factory method to create a Tuple6.

fun <A1, A2, A3, A4, A5, A6, A7> Tuple(a1: A1, a2: A2, a3: A3, a4: A4, a5: A5, a6: A6, a7: A7): Tuple7<A1, A2, A3, A4, A5, A6, A7>

Factory method to create a Tuple7.

fun <A1, A2, A3, A4, A5, A6, A7, A8> Tuple(a1: A1, a2: A2, a3: A3, a4: A4, a5: A5, a6: A6, a7: A7, a8: A8): Tuple8<A1, A2, A3, A4, A5, A6, A7, A8>

Factory method to create a Tuple8.

fun <A1, A2, A3, A4, A5, A6, A7, A8, A9> Tuple(a1: A1, a2: A2, a3: A3, a4: A4, a5: A5, a6: A6, a7: A7, a8: A8, a9: A9): Tuple9<A1, A2, A3, A4, A5, A6, A7, A8, A9>

Factory method to create a Tuple9.

varargToList

fun <T> varargToList(arg: T, otherArgs: Array<out T>): List<T>

fun varargToList(arg: Boolean, otherArgs: BooleanArray): List<Boolean>

fun varargToList(arg: Byte, otherArgs: ByteArray): List<Byte>

fun varargToList(arg: Char, otherArgs: CharArray): List<Char>

fun varargToList(arg: Double, otherArgs: DoubleArray): List<Double>

fun varargToList(arg: Float, otherArgs: FloatArray): List<Float>

fun varargToList(arg: Int, otherArgs: IntArray): List<Int>

fun varargToList(arg: Long, otherArgs: LongArray): List<Long>

fun varargToList(arg: Short, otherArgs: ShortArray): List<Short>

Adds the given arg and the otherArgs into a new List and returns it.