kommons-array/de.jessestricker.kommons.array

Package-level declarations

Types

DelicateKommonsArrayApi

annotation class DelicateKommonsArrayApi

Marks declarations that should be used carefully because they may break type safety or invariants.

ImmutableBooleanArray

@JvmInline

value class ImmutableBooleanArray

An immutable array of booleans.

ImmutableByteArray

@JvmInline

value class ImmutableByteArray

An immutable array of bytes.

ImmutableCharArray

@JvmInline

value class ImmutableCharArray

An immutable array of chars.

ImmutableDoubleArray

@JvmInline

value class ImmutableDoubleArray

An immutable array of doubles.

ImmutableFloatArray

@JvmInline

value class ImmutableFloatArray

An immutable array of floats.

ImmutableIntArray

@JvmInline

value class ImmutableIntArray

An immutable array of ints.

ImmutableLongArray

@JvmInline

value class ImmutableLongArray

An immutable array of longs.

ImmutableShortArray

@JvmInline

value class ImmutableShortArray

An immutable array of shorts.

ImmutableUByteArray

@ExperimentalUnsignedTypes

@JvmInline

value class ImmutableUByteArray

An immutable array of unsigned bytes.

ImmutableUIntArray

@ExperimentalUnsignedTypes

@JvmInline

value class ImmutableUIntArray

An immutable array of unsigned ints.

ImmutableULongArray

@ExperimentalUnsignedTypes

@JvmInline

value class ImmutableULongArray

An immutable array of unsigned longs.

ImmutableUShortArray

@ExperimentalUnsignedTypes

@JvmInline

value class ImmutableUShortArray

An immutable array of unsigned shorts.

Properties

indices

lastIndex

Functions

asImmutableArray

@DelicateKommonsArrayApi

fun BooleanArray.asImmutableArray(): ImmutableBooleanArray

@DelicateKommonsArrayApi

fun ByteArray.asImmutableArray(): ImmutableByteArray

@DelicateKommonsArrayApi

fun CharArray.asImmutableArray(): ImmutableCharArray

@DelicateKommonsArrayApi

fun DoubleArray.asImmutableArray(): ImmutableDoubleArray

@DelicateKommonsArrayApi

fun FloatArray.asImmutableArray(): ImmutableFloatArray

@DelicateKommonsArrayApi

fun IntArray.asImmutableArray(): ImmutableIntArray

@DelicateKommonsArrayApi

fun LongArray.asImmutableArray(): ImmutableLongArray

@DelicateKommonsArrayApi

fun ShortArray.asImmutableArray(): ImmutableShortArray

@ExperimentalUnsignedTypes

@DelicateKommonsArrayApi

fun UByteArray.asImmutableArray(): ImmutableUByteArray

@ExperimentalUnsignedTypes

@DelicateKommonsArrayApi

fun UIntArray.asImmutableArray(): ImmutableUIntArray

@ExperimentalUnsignedTypes

@DelicateKommonsArrayApi

fun ULongArray.asImmutableArray(): ImmutableULongArray

@ExperimentalUnsignedTypes

@DelicateKommonsArrayApi

fun UShortArray.asImmutableArray(): ImmutableUShortArray

asImmutableByteArray

@ExperimentalUnsignedTypes

fun ImmutableUByteArray.asImmutableByteArray(): ImmutableByteArray

asImmutableIntArray

@ExperimentalUnsignedTypes

fun ImmutableUIntArray.asImmutableIntArray(): ImmutableIntArray

asImmutableLongArray

@ExperimentalUnsignedTypes

fun ImmutableULongArray.asImmutableLongArray(): ImmutableLongArray

asImmutableShortArray

@ExperimentalUnsignedTypes

fun ImmutableUShortArray.asImmutableShortArray(): ImmutableShortArray

asList

fun ImmutableBooleanArray.asList(): List<Boolean>

fun ImmutableByteArray.asList(): List<Byte>

fun ImmutableCharArray.asList(): List<Char>

fun ImmutableDoubleArray.asList(): List<Double>

fun ImmutableFloatArray.asList(): List<Float>

fun ImmutableIntArray.asList(): List<Int>

fun ImmutableLongArray.asList(): List<Long>

fun ImmutableShortArray.asList(): List<Short>

@ExperimentalUnsignedTypes

fun ImmutableUByteArray.asList(): List<UByte>

@ExperimentalUnsignedTypes

fun ImmutableUIntArray.asList(): List<UInt>

@ExperimentalUnsignedTypes

fun ImmutableULongArray.asList(): List<ULong>

@ExperimentalUnsignedTypes

fun ImmutableUShortArray.asList(): List<UShort>

asMutableArray

@DelicateKommonsArrayApi

fun ImmutableBooleanArray.asMutableArray(): BooleanArray

@DelicateKommonsArrayApi

fun ImmutableByteArray.asMutableArray(): ByteArray

@DelicateKommonsArrayApi

fun ImmutableCharArray.asMutableArray(): CharArray

@DelicateKommonsArrayApi

fun ImmutableDoubleArray.asMutableArray(): DoubleArray

@DelicateKommonsArrayApi

fun ImmutableFloatArray.asMutableArray(): FloatArray

@DelicateKommonsArrayApi

fun ImmutableIntArray.asMutableArray(): IntArray

@DelicateKommonsArrayApi

fun ImmutableLongArray.asMutableArray(): LongArray

@DelicateKommonsArrayApi

fun ImmutableShortArray.asMutableArray(): ShortArray

@ExperimentalUnsignedTypes

@DelicateKommonsArrayApi

fun ImmutableUByteArray.asMutableArray(): UByteArray

@ExperimentalUnsignedTypes

@DelicateKommonsArrayApi

fun ImmutableUIntArray.asMutableArray(): UIntArray

@ExperimentalUnsignedTypes

@DelicateKommonsArrayApi

fun ImmutableULongArray.asMutableArray(): ULongArray

@ExperimentalUnsignedTypes

@DelicateKommonsArrayApi

fun ImmutableUShortArray.asMutableArray(): UShortArray

contains

operator fun ImmutableBooleanArray.contains(element: Boolean): Boolean

operator fun ImmutableByteArray.contains(element: Byte): Boolean

operator fun ImmutableCharArray.contains(element: Char): Boolean

operator fun ImmutableIntArray.contains(element: Int): Boolean

operator fun ImmutableLongArray.contains(element: Long): Boolean

operator fun ImmutableShortArray.contains(element: Short): Boolean

@ExperimentalUnsignedTypes

operator fun ImmutableUByteArray.contains(element: UByte): Boolean

@ExperimentalUnsignedTypes

operator fun ImmutableUIntArray.contains(element: UInt): Boolean

@ExperimentalUnsignedTypes

operator fun ImmutableULongArray.contains(element: ULong): Boolean

@ExperimentalUnsignedTypes

operator fun ImmutableUShortArray.contains(element: UShort): Boolean

contentEquals

infix fun ImmutableBooleanArray?.contentEquals(other: ImmutableBooleanArray?): Boolean

infix fun ImmutableByteArray?.contentEquals(other: ImmutableByteArray?): Boolean

infix fun ImmutableCharArray?.contentEquals(other: ImmutableCharArray?): Boolean

infix fun ImmutableDoubleArray?.contentEquals(other: ImmutableDoubleArray?): Boolean

infix fun ImmutableFloatArray?.contentEquals(other: ImmutableFloatArray?): Boolean

infix fun ImmutableIntArray?.contentEquals(other: ImmutableIntArray?): Boolean

infix fun ImmutableLongArray?.contentEquals(other: ImmutableLongArray?): Boolean

infix fun ImmutableShortArray?.contentEquals(other: ImmutableShortArray?): Boolean

@ExperimentalUnsignedTypes

infix fun ImmutableUByteArray?.contentEquals(other: ImmutableUByteArray?): Boolean

@ExperimentalUnsignedTypes

infix fun ImmutableUIntArray?.contentEquals(other: ImmutableUIntArray?): Boolean

@ExperimentalUnsignedTypes

infix fun ImmutableULongArray?.contentEquals(other: ImmutableULongArray?): Boolean

@ExperimentalUnsignedTypes

infix fun ImmutableUShortArray?.contentEquals(other: ImmutableUShortArray?): Boolean

contentHashCode

fun ImmutableBooleanArray?.contentHashCode(): Int

fun ImmutableByteArray?.contentHashCode(): Int

fun ImmutableCharArray?.contentHashCode(): Int

fun ImmutableDoubleArray?.contentHashCode(): Int

fun ImmutableFloatArray?.contentHashCode(): Int

fun ImmutableIntArray?.contentHashCode(): Int

fun ImmutableLongArray?.contentHashCode(): Int

fun ImmutableShortArray?.contentHashCode(): Int

@ExperimentalUnsignedTypes

fun ImmutableUByteArray?.contentHashCode(): Int

@ExperimentalUnsignedTypes

fun ImmutableUIntArray?.contentHashCode(): Int

@ExperimentalUnsignedTypes

fun ImmutableULongArray?.contentHashCode(): Int

@ExperimentalUnsignedTypes

fun ImmutableUShortArray?.contentHashCode(): Int

contentToString

copyInto

fun ImmutableBooleanArray.copyInto(destination: BooleanArray, destinationOffset: Int = 0, startIndex: Int = 0, endIndex: Int = size): BooleanArray

fun ImmutableByteArray.copyInto(destination: ByteArray, destinationOffset: Int = 0, startIndex: Int = 0, endIndex: Int = size): ByteArray

fun ImmutableCharArray.copyInto(destination: CharArray, destinationOffset: Int = 0, startIndex: Int = 0, endIndex: Int = size): CharArray

fun ImmutableDoubleArray.copyInto(destination: DoubleArray, destinationOffset: Int = 0, startIndex: Int = 0, endIndex: Int = size): DoubleArray

fun ImmutableFloatArray.copyInto(destination: FloatArray, destinationOffset: Int = 0, startIndex: Int = 0, endIndex: Int = size): FloatArray

fun ImmutableIntArray.copyInto(destination: IntArray, destinationOffset: Int = 0, startIndex: Int = 0, endIndex: Int = size): IntArray

fun ImmutableLongArray.copyInto(destination: LongArray, destinationOffset: Int = 0, startIndex: Int = 0, endIndex: Int = size): LongArray

fun ImmutableShortArray.copyInto(destination: ShortArray, destinationOffset: Int = 0, startIndex: Int = 0, endIndex: Int = size): ShortArray

@ExperimentalUnsignedTypes

fun ImmutableUByteArray.copyInto(destination: UByteArray, destinationOffset: Int = 0, startIndex: Int = 0, endIndex: Int = size): UByteArray

@ExperimentalUnsignedTypes

fun ImmutableUIntArray.copyInto(destination: UIntArray, destinationOffset: Int = 0, startIndex: Int = 0, endIndex: Int = size): UIntArray

@ExperimentalUnsignedTypes

fun ImmutableULongArray.copyInto(destination: ULongArray, destinationOffset: Int = 0, startIndex: Int = 0, endIndex: Int = size): ULongArray

@ExperimentalUnsignedTypes

fun ImmutableUShortArray.copyInto(destination: UShortArray, destinationOffset: Int = 0, startIndex: Int = 0, endIndex: Int = size): UShortArray

copyOf

fun ImmutableBooleanArray.copyOf(): ImmutableBooleanArray

fun ImmutableByteArray.copyOf(): ImmutableByteArray

fun ImmutableCharArray.copyOf(): ImmutableCharArray

fun ImmutableDoubleArray.copyOf(): ImmutableDoubleArray

fun ImmutableFloatArray.copyOf(): ImmutableFloatArray

fun ImmutableIntArray.copyOf(): ImmutableIntArray

fun ImmutableLongArray.copyOf(): ImmutableLongArray

fun ImmutableShortArray.copyOf(): ImmutableShortArray

@ExperimentalUnsignedTypes

fun ImmutableUByteArray.copyOf(): ImmutableUByteArray

@ExperimentalUnsignedTypes

fun ImmutableUIntArray.copyOf(): ImmutableUIntArray

@ExperimentalUnsignedTypes

fun ImmutableULongArray.copyOf(): ImmutableULongArray

@ExperimentalUnsignedTypes

fun ImmutableUShortArray.copyOf(): ImmutableUShortArray

fun ImmutableBooleanArray.copyOf(newSize: Int): ImmutableBooleanArray

fun ImmutableByteArray.copyOf(newSize: Int): ImmutableByteArray

fun ImmutableCharArray.copyOf(newSize: Int): ImmutableCharArray

fun ImmutableDoubleArray.copyOf(newSize: Int): ImmutableDoubleArray

fun ImmutableFloatArray.copyOf(newSize: Int): ImmutableFloatArray

fun ImmutableIntArray.copyOf(newSize: Int): ImmutableIntArray

fun ImmutableLongArray.copyOf(newSize: Int): ImmutableLongArray

fun ImmutableShortArray.copyOf(newSize: Int): ImmutableShortArray

@ExperimentalUnsignedTypes

fun ImmutableUByteArray.copyOf(newSize: Int): ImmutableUByteArray

@ExperimentalUnsignedTypes

fun ImmutableUIntArray.copyOf(newSize: Int): ImmutableUIntArray

@ExperimentalUnsignedTypes

fun ImmutableULongArray.copyOf(newSize: Int): ImmutableULongArray

@ExperimentalUnsignedTypes

fun ImmutableUShortArray.copyOf(newSize: Int): ImmutableUShortArray

copyOfRange

fun ImmutableBooleanArray.copyOfRange(fromIndex: Int, toIndex: Int): ImmutableBooleanArray

fun ImmutableByteArray.copyOfRange(fromIndex: Int, toIndex: Int): ImmutableByteArray

fun ImmutableCharArray.copyOfRange(fromIndex: Int, toIndex: Int): ImmutableCharArray

fun ImmutableDoubleArray.copyOfRange(fromIndex: Int, toIndex: Int): ImmutableDoubleArray

fun ImmutableFloatArray.copyOfRange(fromIndex: Int, toIndex: Int): ImmutableFloatArray

fun ImmutableIntArray.copyOfRange(fromIndex: Int, toIndex: Int): ImmutableIntArray

fun ImmutableLongArray.copyOfRange(fromIndex: Int, toIndex: Int): ImmutableLongArray

fun ImmutableShortArray.copyOfRange(fromIndex: Int, toIndex: Int): ImmutableShortArray

@ExperimentalUnsignedTypes

fun ImmutableUByteArray.copyOfRange(fromIndex: Int, toIndex: Int): ImmutableUByteArray

@ExperimentalUnsignedTypes

fun ImmutableUIntArray.copyOfRange(fromIndex: Int, toIndex: Int): ImmutableUIntArray

@ExperimentalUnsignedTypes

fun ImmutableULongArray.copyOfRange(fromIndex: Int, toIndex: Int): ImmutableULongArray

@ExperimentalUnsignedTypes

fun ImmutableUShortArray.copyOfRange(fromIndex: Int, toIndex: Int): ImmutableUShortArray

indexOf

fun ImmutableBooleanArray.indexOf(element: Boolean): Int

fun ImmutableByteArray.indexOf(element: Byte): Int

fun ImmutableCharArray.indexOf(element: Char): Int

fun ImmutableIntArray.indexOf(element: Int): Int

fun ImmutableLongArray.indexOf(element: Long): Int

fun ImmutableShortArray.indexOf(element: Short): Int

@ExperimentalUnsignedTypes

fun ImmutableUByteArray.indexOf(element: UByte): Int

@ExperimentalUnsignedTypes

fun ImmutableUIntArray.indexOf(element: UInt): Int

@ExperimentalUnsignedTypes

fun ImmutableULongArray.indexOf(element: ULong): Int

@ExperimentalUnsignedTypes

fun ImmutableUShortArray.indexOf(element: UShort): Int

isEmpty

fun ImmutableBooleanArray.isEmpty(): Boolean

fun ImmutableByteArray.isEmpty(): Boolean

fun ImmutableCharArray.isEmpty(): Boolean

fun ImmutableDoubleArray.isEmpty(): Boolean

fun ImmutableFloatArray.isEmpty(): Boolean

fun ImmutableIntArray.isEmpty(): Boolean

fun ImmutableLongArray.isEmpty(): Boolean

fun ImmutableShortArray.isEmpty(): Boolean

@ExperimentalUnsignedTypes

fun ImmutableUByteArray.isEmpty(): Boolean

@ExperimentalUnsignedTypes

fun ImmutableUIntArray.isEmpty(): Boolean

@ExperimentalUnsignedTypes

fun ImmutableULongArray.isEmpty(): Boolean

@ExperimentalUnsignedTypes

fun ImmutableUShortArray.isEmpty(): Boolean

isNotEmpty

lastIndexOf

fun ImmutableBooleanArray.lastIndexOf(element: Boolean): Int

fun ImmutableByteArray.lastIndexOf(element: Byte): Int

fun ImmutableCharArray.lastIndexOf(element: Char): Int

fun ImmutableIntArray.lastIndexOf(element: Int): Int

fun ImmutableLongArray.lastIndexOf(element: Long): Int

fun ImmutableShortArray.lastIndexOf(element: Short): Int

@ExperimentalUnsignedTypes

fun ImmutableUByteArray.lastIndexOf(element: UByte): Int

@ExperimentalUnsignedTypes

fun ImmutableUIntArray.lastIndexOf(element: UInt): Int

@ExperimentalUnsignedTypes

fun ImmutableULongArray.lastIndexOf(element: ULong): Int

@ExperimentalUnsignedTypes

fun ImmutableUShortArray.lastIndexOf(element: UShort): Int

plus

operator fun ImmutableBooleanArray.plus(elements: ImmutableBooleanArray): ImmutableBooleanArray

operator fun ImmutableBooleanArray.plus(element: Boolean): ImmutableBooleanArray

operator fun ImmutableBooleanArray.plus(elements: BooleanArray): ImmutableBooleanArray

operator fun ImmutableBooleanArray.plus(elements: Collection<Boolean>): ImmutableBooleanArray

operator fun ImmutableByteArray.plus(elements: ImmutableByteArray): ImmutableByteArray

operator fun ImmutableByteArray.plus(element: Byte): ImmutableByteArray

operator fun ImmutableByteArray.plus(elements: ByteArray): ImmutableByteArray

operator fun ImmutableByteArray.plus(elements: Collection<Byte>): ImmutableByteArray

operator fun ImmutableCharArray.plus(elements: ImmutableCharArray): ImmutableCharArray

operator fun ImmutableCharArray.plus(element: Char): ImmutableCharArray

operator fun ImmutableCharArray.plus(elements: CharArray): ImmutableCharArray

operator fun ImmutableCharArray.plus(elements: Collection<Char>): ImmutableCharArray

operator fun ImmutableDoubleArray.plus(elements: ImmutableDoubleArray): ImmutableDoubleArray

operator fun ImmutableDoubleArray.plus(element: Double): ImmutableDoubleArray

operator fun ImmutableDoubleArray.plus(elements: DoubleArray): ImmutableDoubleArray

operator fun ImmutableDoubleArray.plus(elements: Collection<Double>): ImmutableDoubleArray

operator fun ImmutableFloatArray.plus(elements: ImmutableFloatArray): ImmutableFloatArray

operator fun ImmutableFloatArray.plus(element: Float): ImmutableFloatArray

operator fun ImmutableFloatArray.plus(elements: FloatArray): ImmutableFloatArray

operator fun ImmutableFloatArray.plus(elements: Collection<Float>): ImmutableFloatArray

operator fun ImmutableIntArray.plus(elements: ImmutableIntArray): ImmutableIntArray

operator fun ImmutableIntArray.plus(element: Int): ImmutableIntArray

operator fun ImmutableIntArray.plus(elements: IntArray): ImmutableIntArray

operator fun ImmutableIntArray.plus(elements: Collection<Int>): ImmutableIntArray

operator fun ImmutableLongArray.plus(elements: ImmutableLongArray): ImmutableLongArray

operator fun ImmutableLongArray.plus(element: Long): ImmutableLongArray

operator fun ImmutableLongArray.plus(elements: LongArray): ImmutableLongArray

operator fun ImmutableLongArray.plus(elements: Collection<Long>): ImmutableLongArray

operator fun ImmutableShortArray.plus(elements: ImmutableShortArray): ImmutableShortArray

operator fun ImmutableShortArray.plus(element: Short): ImmutableShortArray

operator fun ImmutableShortArray.plus(elements: ShortArray): ImmutableShortArray

operator fun ImmutableShortArray.plus(elements: Collection<Short>): ImmutableShortArray

@ExperimentalUnsignedTypes

operator fun ImmutableUByteArray.plus(elements: ImmutableUByteArray): ImmutableUByteArray

@ExperimentalUnsignedTypes

operator fun ImmutableUByteArray.plus(element: UByte): ImmutableUByteArray

@ExperimentalUnsignedTypes

operator fun ImmutableUByteArray.plus(elements: UByteArray): ImmutableUByteArray

@ExperimentalUnsignedTypes

operator fun ImmutableUByteArray.plus(elements: Collection<UByte>): ImmutableUByteArray

@ExperimentalUnsignedTypes

operator fun ImmutableUIntArray.plus(elements: ImmutableUIntArray): ImmutableUIntArray

@ExperimentalUnsignedTypes

operator fun ImmutableUIntArray.plus(element: UInt): ImmutableUIntArray

@ExperimentalUnsignedTypes

operator fun ImmutableUIntArray.plus(elements: UIntArray): ImmutableUIntArray

@ExperimentalUnsignedTypes

operator fun ImmutableUIntArray.plus(elements: Collection<UInt>): ImmutableUIntArray

@ExperimentalUnsignedTypes

operator fun ImmutableULongArray.plus(elements: ImmutableULongArray): ImmutableULongArray

@ExperimentalUnsignedTypes

operator fun ImmutableULongArray.plus(element: ULong): ImmutableULongArray

@ExperimentalUnsignedTypes

operator fun ImmutableULongArray.plus(elements: ULongArray): ImmutableULongArray

@ExperimentalUnsignedTypes

operator fun ImmutableULongArray.plus(elements: Collection<ULong>): ImmutableULongArray

@ExperimentalUnsignedTypes

operator fun ImmutableUShortArray.plus(elements: ImmutableUShortArray): ImmutableUShortArray

@ExperimentalUnsignedTypes

operator fun ImmutableUShortArray.plus(element: UShort): ImmutableUShortArray

@ExperimentalUnsignedTypes

operator fun ImmutableUShortArray.plus(elements: UShortArray): ImmutableUShortArray

@ExperimentalUnsignedTypes

operator fun ImmutableUShortArray.plus(elements: Collection<UShort>): ImmutableUShortArray

reversedArray

sliceArray

fun ImmutableBooleanArray.sliceArray(indices: Collection<Int>): ImmutableBooleanArray

fun ImmutableBooleanArray.sliceArray(indices: IntRange): ImmutableBooleanArray

fun ImmutableByteArray.sliceArray(indices: Collection<Int>): ImmutableByteArray

fun ImmutableByteArray.sliceArray(indices: IntRange): ImmutableByteArray

fun ImmutableCharArray.sliceArray(indices: Collection<Int>): ImmutableCharArray

fun ImmutableCharArray.sliceArray(indices: IntRange): ImmutableCharArray

fun ImmutableDoubleArray.sliceArray(indices: Collection<Int>): ImmutableDoubleArray

fun ImmutableDoubleArray.sliceArray(indices: IntRange): ImmutableDoubleArray

fun ImmutableFloatArray.sliceArray(indices: Collection<Int>): ImmutableFloatArray

fun ImmutableFloatArray.sliceArray(indices: IntRange): ImmutableFloatArray

fun ImmutableIntArray.sliceArray(indices: Collection<Int>): ImmutableIntArray

fun ImmutableIntArray.sliceArray(indices: IntRange): ImmutableIntArray

fun ImmutableLongArray.sliceArray(indices: Collection<Int>): ImmutableLongArray

fun ImmutableLongArray.sliceArray(indices: IntRange): ImmutableLongArray

fun ImmutableShortArray.sliceArray(indices: Collection<Int>): ImmutableShortArray

fun ImmutableShortArray.sliceArray(indices: IntRange): ImmutableShortArray

@ExperimentalUnsignedTypes

fun ImmutableUByteArray.sliceArray(indices: Collection<Int>): ImmutableUByteArray

@ExperimentalUnsignedTypes

fun ImmutableUByteArray.sliceArray(indices: IntRange): ImmutableUByteArray

@ExperimentalUnsignedTypes

fun ImmutableUIntArray.sliceArray(indices: Collection<Int>): ImmutableUIntArray

@ExperimentalUnsignedTypes

fun ImmutableUIntArray.sliceArray(indices: IntRange): ImmutableUIntArray

@ExperimentalUnsignedTypes

fun ImmutableULongArray.sliceArray(indices: Collection<Int>): ImmutableULongArray

@ExperimentalUnsignedTypes

fun ImmutableULongArray.sliceArray(indices: IntRange): ImmutableULongArray

@ExperimentalUnsignedTypes

fun ImmutableUShortArray.sliceArray(indices: Collection<Int>): ImmutableUShortArray

@ExperimentalUnsignedTypes

fun ImmutableUShortArray.sliceArray(indices: IntRange): ImmutableUShortArray

sortedArray

toImmutableArray

toMutableArray