Compukters Core/kotlin

Package-level declarations

Types

Any

open class Any

ArithmeticException

class ArithmeticException(message: String?, cause: Throwable? = null) : RuntimeException

Array

class Array<T>

Boolean

class Boolean : Comparable<Boolean>

BooleanArray

class BooleanArray

Byte

class Byte : Number, Comparable<Byte>

ByteArray

class ByteArray

Char

class Char : Comparable<Char>

CharArray

class CharArray

CharSequence

interface CharSequence

ClassCastException

class ClassCastException(message: String?, cause: Throwable? = null) : RuntimeException

Comparable

interface Comparable<in T>

Deprecated

annotation class Deprecated(val message: String)

Double

class Double : Number, Comparable<Double>

DoubleArray

class DoubleArray

Enum

abstract class Enum<E : Enum<E>> : Comparable<E>

Exception

open class Exception(message: String?, cause: Throwable? = null) : Throwable

ExtensionFunctionType

annotation class ExtensionFunctionType

Float

class Float : Number, Comparable<Float>

FloatArray

class FloatArray

Function

interface Function<out R>

Function0

interface Function0<out R> : Function<R>

Function1

interface Function1<in P1, out R> : Function<R>

Function2

interface Function2<in P1, in P2, out R> : Function<R>

IllegalArgumentException

class IllegalArgumentException(message: String?, cause: Throwable? = null) : RuntimeException

IllegalStateException

open class IllegalStateException(message: String?, cause: Throwable? = null) : RuntimeException

IndexOutOfBoundsException

open class IndexOutOfBoundsException(message: String?, cause: Throwable? = null) : RuntimeException

Int

class Int : Number, Comparable<Int>

IntArray

class IntArray

Long

class Long : Number, Comparable<Long>

LongArray

class LongArray

NegativeArraySizeException

class NegativeArraySizeException(message: String?, cause: Throwable? = null) : RuntimeException

NoSuchElementException

class NoSuchElementException(message: String?, cause: Throwable? = null) : RuntimeException

No element satisfies a required collection or peripheral selection.

Nothing

class Nothing

NoWhenBranchMatchedException

class NoWhenBranchMatchedException : RuntimeException

NullPointerException

class NullPointerException(message: String?, cause: Throwable? = null) : RuntimeException

Number

abstract class Number

ParameterName

annotation class ParameterName(val name: String)

PublishedApi

annotation class PublishedApi

RuntimeException

open class RuntimeException(message: String?, cause: Throwable? = null) : Exception

Short

class Short : Number, Comparable<Short>

ShortArray

class ShortArray

String

class String : Comparable<String> , CharSequence

Suppress

annotation class Suppress(val names: String)

Throwable

open class Throwable(message: String?)

UByte

class UByte : Comparable<UByte>

UByteArray

class UByteArray

UInt

class UInt : Comparable<UInt>

UIntArray

class UIntArray

ULong

class ULong : Comparable<ULong>

ULongArray

class ULongArray

Unit

object Unit

UnsafeVariance

annotation class UnsafeVariance

UShort

class UShort : Comparable<UShort>

UShortArray

class UShortArray

Functions

also

inline fun <T> T.also(block: (T) -> Unit): T

Calls block with this value and returns this value.

apply

inline fun <T> T.apply(block: T.() -> Unit): T

Calls block with this value as its receiver and returns this value.

arrayOf

external fun <T> arrayOf(vararg elements: T): Array<T>

arrayOfNulls

external fun <T> arrayOfNulls(size: Int): Array<T?>

Creates an array of the requested size with every element set to null.

booleanArrayOf

external fun booleanArrayOf(vararg elements: Boolean): BooleanArray

byteArrayOf

external fun byteArrayOf(vararg elements: Byte): ByteArray

charArrayOf

external fun charArrayOf(vararg elements: Char): CharArray

check

fun check(value: Boolean)

inline fun check(value: Boolean, lazyMessage: () -> Any)

doubleArrayOf

external fun doubleArrayOf(vararg elements: Double): DoubleArray

emptyArray

external fun <T> emptyArray(): Array<T>

error

fun error(message: String): Nothing

floatArrayOf

external fun floatArrayOf(vararg elements: Float): FloatArray

hashCode

fun Any?.hashCode(): Int

intArrayOf

external fun intArrayOf(vararg elements: Int): IntArray

let

inline fun <T, R> T.let(block: (T) -> R): R

Calls block with this value and returns its result.

longArrayOf

external fun longArrayOf(vararg elements: Long): LongArray

repeat

inline fun repeat(times: Int, action: (Int) -> Unit)

Calls action with each index from zero until times, or not at all for non-positive counts.

require

fun require(value: Boolean)

inline fun require(value: Boolean, lazyMessage: () -> Any)

run

inline fun <R> run(block: () -> R): R

Calls block without a receiver and returns its result.

run

inline fun <T, R> T.run(block: T.() -> R): R

Calls block with this value as its receiver and returns its result.

shortArrayOf

external fun shortArrayOf(vararg elements: Short): ShortArray

takeIf

inline fun <T> T.takeIf(predicate: (T) -> Boolean): T?

Returns this value when predicate is true, or null otherwise.

takeUnless

inline fun <T> T.takeUnless(predicate: (T) -> Boolean): T?

Returns this value when predicate is false, or null otherwise.

toString

external fun <T> T?.toString(): String

ubyteArrayOf

external fun ubyteArrayOf(vararg elements: UByte): UByteArray

uintArrayOf

external fun uintArrayOf(vararg elements: UInt): UIntArray

ulongArrayOf

external fun ulongArrayOf(vararg elements: ULong): ULongArray

ushortArrayOf

external fun ushortArrayOf(vararg elements: UShort): UShortArray

with

inline fun <T, R> with(receiver: T, block: T.() -> R): R

Calls block with receiver as its receiver and returns its result.