Compukters Core/kotlin

Package-level declarations

Types

Annotation

interface Annotation

Any

open class Any

ArithmeticException

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

Array

class Array<T>

A fixed-size, mutable array of T elements.

Boolean

class Boolean : Comparable<Boolean>

A truth value, either true or false.

BooleanArray

class BooleanArray

A fixed-size, mutable array of Boolean values.

Byte

class Byte : Number, Comparable<Byte>

A signed 8-bit integer with values from -128 through 127.

ByteArray

class ByteArray

A fixed-size, mutable array of Byte values.

Char

class Char : Comparable<Char>

A single unsigned 16-bit UTF-16 code unit.

CharArray

class CharArray

A fixed-size, mutable array of Char values.

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>

An IEEE 754 binary64 floating-point value.

DoubleArray

class DoubleArray

A fixed-size, mutable array of Double values.

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>

An IEEE 754 binary32 floating-point value.

FloatArray

class FloatArray

A fixed-size, mutable array of Float values.

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

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

A signed 32-bit integer with values from -2,147,483,648 through 2,147,483,647.

IntArray

class IntArray

A fixed-size, mutable array of Int values.

Long

class Long : Number, Comparable<Long>

A signed 64-bit integer with values from -9,223,372,036,854,775,808 through 9,223,372,036,854,775,807.

LongArray

class LongArray

A fixed-size, mutable array of Long values.

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

Common supertype of the signed numeric primitives.

NumberFormatException

class NumberFormatException(message: String?) : IllegalArgumentException

The input cannot be represented as the requested number.

OptIn

annotation class OptIn(val markerClass: KClass<out Annotation>)

Accepts the named experimental markers within this declaration or file.

Pair

class Pair<A, B>(val first: A, val second: B) : PairComponents

Stores two typed values with component-wise equality and positional destructuring.

PairComponents

sealed interface PairComponents

Read-only component view shared by concrete Pair specializations.

ParameterName

annotation class ParameterName(val name: String)

PublishedApi

annotation class PublishedApi

RequiresOptIn

annotation class RequiresOptIn(val message: String = "", val level: RequiresOptIn.Level = Level.ERROR)

Marks declarations whose callers must acknowledge an experimental API.

RuntimeException

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

Short

class Short : Number, Comparable<Short>

A signed 16-bit integer with values from -32,768 through 32,767.

ShortArray

class ShortArray

A fixed-size, mutable array of Short values.

String

class String : Comparable<String> , CharSequence

Suppress

annotation class Suppress(val names: String)

Throwable

open class Throwable(message: String?)

UByte

class UByte : Comparable<UByte>

An unsigned 8-bit integer with values from zero through 255.

UByteArray

class UByteArray

A fixed-size, mutable array of UByte values.

UInt

class UInt : Comparable<UInt>

An unsigned 32-bit integer with values from zero through 4,294,967,295.

UIntArray

class UIntArray

A fixed-size, mutable array of UInt values.

ULong

class ULong : Comparable<ULong>

An unsigned 64-bit integer with values from zero through 18,446,744,073,709,551,615.

ULongArray

class ULongArray

A fixed-size, mutable array of ULong values.

Unit

object Unit

UnsafeVariance

annotation class UnsafeVariance

UShort

class UShort : Comparable<UShort>

An unsigned 16-bit integer with values from zero through 65,535.

UShortArray

class UShortArray

A fixed-size, mutable array of UShort values.

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>

Creates a new array containing elements in argument order.

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

Creates a new array containing elements in argument order.

byteArrayOf

external fun byteArrayOf(vararg elements: Byte): ByteArray

Creates a new array containing elements in argument order.

charArrayOf

external fun charArrayOf(vararg elements: Char): CharArray

Creates a new array containing elements in argument order.

check

fun check(value: Boolean)

Validates a state precondition.

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

Validates a state precondition, computing a message only on failure.

doubleArrayOf

external fun doubleArrayOf(vararg elements: Double): DoubleArray

Creates a new array containing elements in argument order.

emptyArray

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

Creates an empty array with the requested element type.

error

fun error(message: String): Nothing

Stops normal execution by throwing an IllegalStateException.

floatArrayOf

external fun floatArrayOf(vararg elements: Float): FloatArray

Creates a new array containing elements in argument order.

hashCode

fun Any?.hashCode(): Int

intArrayOf

external fun intArrayOf(vararg elements: Int): IntArray

Creates a new array containing elements in argument order.

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

Creates a new array containing elements in argument order.

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)

Validates an argument precondition.

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

Validates an argument precondition, computing a message only on failure.

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

Creates a new array containing elements in argument order.

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.

infix fun <A, B> A.to(that: B): Pair<A, B>

Creates a pair from this value and that, retaining their concrete types.

toString

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

ubyteArrayOf

external fun ubyteArrayOf(vararg elements: UByte): UByteArray

Creates a new array containing elements in argument order.

uintArrayOf

external fun uintArrayOf(vararg elements: UInt): UIntArray

Creates a new array containing elements in argument order.

ulongArrayOf

external fun ulongArrayOf(vararg elements: ULong): ULongArray

Creates a new array containing elements in argument order.

ushortArrayOf

external fun ushortArrayOf(vararg elements: UShort): UShortArray

Creates a new array containing elements in argument order.

with

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

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