Package-level declarations

class DeepRecursiveFunction<T, R>(block: suspend DeepRecursiveScope<T, R>.(T) -> R)

Defines deep recursive function that keeps its stack on the heap, which allows very deep recursive computations that do not use the actual call stack. To initiate a call to this deep recursive function use its invoke function. As a rule of thumb, it should be used if recursion goes deeper than a thousand calls.

Since Kotlin 1.4

DeepRecursiveScope

ExperimentalMultiplatform

sealed class DeepRecursiveScope<T, R>

A scope class for DeepRecursiveFunction function declaration that defines callRecursive methods to recursively call this function or another DeepRecursiveFunction putting the call activation frame on the heap.

Since Kotlin 1.4

Deprecated

@Target(allowedTargets = [AnnotationTarget.CLASS, AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY, AnnotationTarget.ANNOTATION_CLASS, AnnotationTarget.CONSTRUCTOR, AnnotationTarget.PROPERTY_SETTER, AnnotationTarget.PROPERTY_GETTER, AnnotationTarget.TYPEALIAS])

annotation class Deprecated( val message: String, val replaceWith: ReplaceWith = ReplaceWith(""), val level: DeprecationLevel = DeprecationLevel.WARNING)

Marks the annotated declaration as deprecated.

annotation class Deprecated( val message: String, val replaceWith: ReplaceWith = ReplaceWith(""), val level: DeprecationLevel = DeprecationLevel.WARNING)

Marks the annotated declaration as deprecated.

annotation class Deprecated( val message: String, val replaceWith: ReplaceWith = ReplaceWith(""), val level: DeprecationLevel = DeprecationLevel.WARNING)

Marks the annotated declaration as deprecated.

DeprecatedSinceKotlin

annotation class DeprecatedSinceKotlin( val warningSince: String = "", val errorSince: String = "", val hiddenSince: String = "")

Marks the annotated declaration as deprecated. In contrast to Deprecated, severity of the reported diagnostic is not a constant value, but differs depending on the API version of the usage (the value of the -api-version argument when compiling the module where the usage is located). If the API version is greater or equal than hiddenSince, the declaration will not be accessible from the code (as if it was deprecated with level DeprecationLevel.HIDDEN), otherwise if the API version is greater or equal than errorSince, the usage will be marked as an error (as with DeprecationLevel.ERROR), otherwise if the API version is greater or equal than warningSince, the usage will be marked as a warning (as with DeprecationLevel.WARNING), otherwise the annotation is ignored.

Since Kotlin 1.4

annotation class DeprecatedSinceKotlin( val warningSince: String = "", val errorSince: String = "", val hiddenSince: String = "")

Since Kotlin 1.4

annotation class DeprecatedSinceKotlin( val warningSince: String = "", val errorSince: String = "", val hiddenSince: String = "")

Since Kotlin 1.4

DeprecationLevel

enum DeprecationLevel : Enum<DeprecationLevel>

Possible levels of a deprecation. The level specifies how the deprecated element usages are reported in code.

enum DeprecationLevel : Enum<DeprecationLevel>

Possible levels of a deprecation. The level specifies how the deprecated element usages are reported in code.

enum DeprecationLevel : Enum<DeprecationLevel>

Possible levels of a deprecation. The level specifies how the deprecated element usages are reported in code.

Double

class Double : Number, Comparable<Double>

Represents a double-precision 64-bit IEEE 754 floating point number. On the JVM, non-nullable values of this type are represented as values of the primitive type double.

class Double : Number, Comparable<Double>

Represents a double-precision 64-bit IEEE 754 floating point number. On the JVM, non-nullable values of this type are represented as values of the primitive type double.

class Double : Number, Comparable<Double>

Represents a double-precision 64-bit IEEE 754 floating point number.

DoubleArray

class DoubleArray(size: Int)

An array of doubles. When targeting the JVM, instances of this class are represented as double[].

class DoubleArray(size: Int)

An array of doubles. When targeting the JVM, instances of this class are represented as double[].

class DoubleArray

DslMarker

@Target(allowedTargets = [AnnotationTarget.ANNOTATION_CLASS])

annotation class DslMarker

When applied to annotation class X specifies that X defines a DSL language

Since Kotlin 1.1

@Target(allowedTargets = [AnnotationTarget.ANNOTATION_CLASS])

annotation class DslMarker

When applied to annotation class X specifies that X defines a DSL language

Since Kotlin 1.1

@Target(allowedTargets = [AnnotationTarget.ANNOTATION_CLASS])

annotation class DslMarker

When applied to annotation class X specifies that X defines a DSL language

Since Kotlin 1.1

Enum

abstract class Enum<E : Enum<E>>(name: String, ordinal: Int) : Comparable<E>

The common base class of all enum classes. See the Kotlin language documentation for more information on enum classes.

abstract class Enum<E : Enum<E>>(name: String, ordinal: Int) : Comparable<E>

The common base class of all enum classes. See the Kotlin language documentation for more information on enum classes.

abstract class Enum<E : Enum<E>>(name: String, ordinal: Int) : Comparable<E>

The common base class of all enum classes. See the Kotlin language documentation for more information on enum classes.

abstract class Enum<E : Enum<E>>(val name: String, val ordinal: Int) : Comparable<E>

The common base class of all enum classes. See the Kotlin language documentation for more information on enum classes.

Error

expect open class Error(message: String?, cause: Throwable?) : Throwable

actual typealias Error = Error

actual open class Error(val message: String?, val cause: Throwable?) : Throwable

Exception

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

actual typealias Exception = Exception

actual open class Exception(val message: String?, val cause: Throwable?) : Throwable

Experimental

@Target(allowedTargets = [AnnotationTarget.ANNOTATION_CLASS])

annotation class ~~Experimental~~(val level: Experimental.Level = Level.ERROR)

Signals that the annotated annotation class is a marker of an experimental API.

Since Kotlin 1.2

@Target(allowedTargets = [AnnotationTarget.CLASS, AnnotationTarget.ANNOTATION_CLASS, AnnotationTarget.PROPERTY, AnnotationTarget.FIELD, AnnotationTarget.LOCAL_VARIABLE, AnnotationTarget.VALUE_PARAMETER, AnnotationTarget.CONSTRUCTOR, AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY_GETTER, AnnotationTarget.PROPERTY_SETTER, AnnotationTarget.TYPEALIAS])

annotation class ExperimentalMultiplatform

The experimental multiplatform support API marker.

ExperimentalStdlibApi

annotation class ExperimentalStdlibApi

This annotation marks the standard library API that is considered experimental and is not subject to the general compatibility guarantees given for the standard library: the behavior of such API may be changed or the API may be removed completely in any further release.

Since Kotlin 1.3

ExperimentalUnsignedTypes

annotation class ExperimentalUnsignedTypes

Marks the API that is dependent on the experimental unsigned types, including those types themselves.

ExtensionFunctionType

@Target(allowedTargets = [AnnotationTarget.TYPE])

annotation class ExtensionFunctionType

Signifies that the annotated functional type represents an extension function.

@Target(allowedTargets = [AnnotationTarget.TYPE])

annotation class ExtensionFunctionType

Signifies that the annotated functional type represents an extension function.

@Target(allowedTargets = [AnnotationTarget.TYPE])

annotation class ExtensionFunctionType

Signifies that the annotated functional type represents an extension function.

Float

class Float : Number, Comparable<Float>

Represents a single-precision 32-bit IEEE 754 floating point number. On the JVM, non-nullable values of this type are represented as values of the primitive type float.

class Float : Number, Comparable<Float>

Represents a single-precision 32-bit IEEE 754 floating point number. On the JVM, non-nullable values of this type are represented as values of the primitive type float.

class Float : Number, Comparable<Float>

Represents a single-precision 32-bit IEEE 754 floating point number.

FloatArray

class FloatArray(size: Int)

An array of floats. When targeting the JVM, instances of this class are represented as float[].

class FloatArray(size: Int)

An array of floats. When targeting the JVM, instances of this class are represented as float[].

class FloatArray

An array of floats.

Function

interface Function<out R>

Represents a value of a functional type, such as a lambda, an anonymous function or a function reference.

interface Function<out R>

Represents a value of a functional type, such as a lambda, an anonymous function or a function reference.

interface Function<out R>

Represents a value of a functional type, such as a lambda, an anonymous function or a function reference.

interface Function<out R>

Represents a value of a functional type, such as a lambda, an anonymous function or a function reference.

IllegalArgumentException

expect open class IllegalArgumentException(message: String?, cause: Throwable?) : RuntimeException

actual typealias IllegalArgumentException = IllegalArgumentException

actual open class IllegalArgumentException(val message: String?, val cause: Throwable?) : RuntimeException

IllegalStateException

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

actual typealias IllegalStateException = IllegalStateException

actual open class IllegalStateException(val message: String?, val cause: Throwable?) : RuntimeException

IndexOutOfBoundsException

expect open class IndexOutOfBoundsException(message: String?) : RuntimeException

actual typealias IndexOutOfBoundsException = IndexOutOfBoundsException

actual open class IndexOutOfBoundsException(val message: String?) : RuntimeException

Int

class Int : Number, Comparable<Int>

Represents a 32-bit signed integer. On the JVM, non-nullable values of this type are represented as values of the primitive type int.

class Int : Number, Comparable<Int>

Represents a 32-bit signed integer. On the JVM, non-nullable values of this type are represented as values of the primitive type int.

class Int : Number, Comparable<Int>

Represents a 32-bit signed integer.

IntArray

class IntArray(size: Int)

An array of ints. When targeting the JVM, instances of this class are represented as int[].

class IntArray(size: Int)

An array of ints. When targeting the JVM, instances of this class are represented as int[].

class IntArray

An array of ints. When targeting the JVM, instances of this class are represented as int[].

KotlinNullPointerException

open class KotlinNullPointerException : NullPointerException

KotlinVersion

class KotlinVersion( val major: Int, val minor: Int, val patch: Int) : Comparable<KotlinVersion>

Represents a version of the Kotlin standard library.

Since Kotlin 1.1

Lazy

interface Lazy<out T>

Represents a value with lazy initialization.

LazyThreadSafetyMode

enum LazyThreadSafetyMode : Enum<LazyThreadSafetyMode>

Specifies how a Lazy instance synchronizes initialization among multiple threads.

Long

class Long : Number, Comparable<Long>

Represents a 64-bit signed integer. On the JVM, non-nullable values of this type are represented as values of the primitive type long.

class Long : Number, Comparable<Long>

Represents a 64-bit signed integer. On the JVM, non-nullable values of this type are represented as values of the primitive type long.

class Long : Number, Comparable<Long>

Represents a 64-bit signed integer.

LongArray

class LongArray(size: Int)

An array of longs. When targeting the JVM, instances of this class are represented as long[].

class LongArray(size: Int)

An array of longs. When targeting the JVM, instances of this class are represented as long[].

class LongArray

An array of longs.

Metadata

@Target(allowedTargets = [AnnotationTarget.CLASS])

annotation class Metadata( val kind: Int = 1, val metadataVersion: IntArray = [], val bytecodeVersion: IntArray = [1, 0, 3], val data1: Array<String> = [], val data2: Array<String> = [], val extraString: String = "", val packageName: String = "", val extraInt: Int = 0)

This annotation is present on any class file produced by the Kotlin compiler and is read by the compiler and reflection. Parameters have very short JVM names on purpose: these names appear in all generated class files, and we'd like to reduce their size.

Since Kotlin 1.3

NoSuchElementException

expect open class NoSuchElementException(message: String?) : RuntimeException

actual typealias NoSuchElementException = NoSuchElementException

actual open class NoSuchElementException(val message: String?) : RuntimeException

Nothing

class Nothing

Nothing has no instances. You can use Nothing to represent "a value that never exists": for example, if a function has the return type of Nothing, it means that it never returns (always throws an exception).

class Nothing

NotImplementedError

class NotImplementedError(message: String = "An operation is not implemented.") : Error

An exception is thrown to indicate that a method body remains to be implemented.

NoWhenBranchMatchedException

expect open class ~~NoWhenBranchMatchedException~~(message: String?, cause: Throwable?) : RuntimeException

actual open class NoWhenBranchMatchedException(message: String?, cause: Throwable?) : RuntimeException

actual open class NoWhenBranchMatchedException(val message: String?, val cause: Throwable?) : RuntimeException

NullPointerException

expect open class NullPointerException(message: String?) : RuntimeException

actual typealias NullPointerException = NullPointerException

actual open class NullPointerException(val message: String?) : RuntimeException

Number

abstract class Number

Superclass for all platform classes representing numeric values.

abstract class Number

Superclass for all platform classes representing numeric values.

abstract class Number

Superclass for all platform classes representing numeric values.

NumberFormatException

expect open class NumberFormatException(message: String?) : IllegalArgumentException

actual typealias NumberFormatException = NumberFormatException

actual open class NumberFormatException(val message: String?) : IllegalArgumentException

OptIn

@Target(allowedTargets = [AnnotationTarget.CLASS, AnnotationTarget.PROPERTY, AnnotationTarget.LOCAL_VARIABLE, AnnotationTarget.VALUE_PARAMETER, AnnotationTarget.CONSTRUCTOR, AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY_GETTER, AnnotationTarget.PROPERTY_SETTER, AnnotationTarget.EXPRESSION, AnnotationTarget.FILE, AnnotationTarget.TYPEALIAS])

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

Allows to use the API denoted by the given markers in the annotated file, declaration, or expression. If a declaration is annotated with OptIn, its usages are not required to opt in to that API.

Since Kotlin 1.3

OptionalExpectation

@Target(allowedTargets = [AnnotationTarget.ANNOTATION_CLASS])

@ExperimentalMultiplatform

annotation class OptionalExpectation

Marks an expected annotation class that it isn't required to have actual counterparts in all platforms.

OutOfMemoryError

open class OutOfMemoryError : Error

OverloadResolutionByLambdaReturnType

@Target(allowedTargets = [AnnotationTarget.FUNCTION])

@ExperimentalTypeInference

annotation class OverloadResolutionByLambdaReturnType

Enables overload selection based on the type of the value returned from lambda argument.

Since Kotlin 1.4

Pair

data class Pair<out A, out B>(val first: A, val second: B) : Serializable

Represents a generic pair of two values.

ParameterName

@Target(allowedTargets = [AnnotationTarget.TYPE])

annotation class ParameterName(val name: String)

Annotates type arguments of functional type and holds corresponding parameter name specified by the user in type declaration (if any).

Since Kotlin 1.1

@Target(allowedTargets = [AnnotationTarget.TYPE])

annotation class ParameterName(val name: String)

Annotates type arguments of functional type and holds corresponding parameter name specified by the user in type declaration (if any).

Since Kotlin 1.1

@Target(allowedTargets = [AnnotationTarget.TYPE])

annotation class ParameterName(val name: String)

Annotates type arguments of functional type and holds corresponding parameter name specified by the user in type declaration (if any).

Since Kotlin 1.1

PublishedApi

@Target(allowedTargets = [AnnotationTarget.CLASS, AnnotationTarget.CONSTRUCTOR, AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY])

annotation class PublishedApi

When applied to a class or a member with internal visibility allows to use it from public inline functions and makes it effectively public.

Since Kotlin 1.1

@Target(allowedTargets = [AnnotationTarget.CLASS, AnnotationTarget.CONSTRUCTOR, AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY])

annotation class PublishedApi

When applied to a class or a member with internal visibility allows to use it from public inline functions and makes it effectively public.

Since Kotlin 1.1

@Target(allowedTargets = [AnnotationTarget.CLASS, AnnotationTarget.CONSTRUCTOR, AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY])

annotation class PublishedApi

When applied to a class or a member with internal visibility allows to use it from public inline functions and makes it effectively public.

Since Kotlin 1.1

ReplaceWith

@Target(allowedTargets = [])

annotation class ReplaceWith(val expression: String, val imports: String)

Specifies a code fragment that can be used to replace a deprecated function, property or class. Tools such as IDEs can automatically apply the replacements specified through this annotation.

@Target(allowedTargets = [])

annotation class ReplaceWith(val expression: String, val imports: String)

Specifies a code fragment that can be used to replace a deprecated function, property or class. Tools such as IDEs can automatically apply the replacements specified through this annotation.

@Target(allowedTargets = [])

annotation class ReplaceWith(val expression: String, val imports: String)

Specifies a code fragment that can be used to replace a deprecated function, property or class. Tools such as IDEs can automatically apply the replacements specified through this annotation.

RequiresOptIn

@Target(allowedTargets = [AnnotationTarget.ANNOTATION_CLASS])

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

Signals that the annotated annotation class is a marker of an API that requires an explicit opt-in.

Since Kotlin 1.3

Result

value class Result<out T> : Serializable

A discriminated union that encapsulates a successful outcome with a value of type T or a failure with an arbitrary Throwable exception.

Since Kotlin 1.3

RuntimeException

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

actual typealias RuntimeException = RuntimeException

actual open class RuntimeException(val message: String?, val cause: Throwable?) : Exception

Short

class Short : Number, Comparable<Short>

Represents a 16-bit signed integer. On the JVM, non-nullable values of this type are represented as values of the primitive type short.

class Short : Number, Comparable<Short>

Represents a 16-bit signed integer. On the JVM, non-nullable values of this type are represented as values of the primitive type short.

class Short : Number, Comparable<Short>

Represents a 16-bit signed integer.

ShortArray

class ShortArray(size: Int)

An array of shorts. When targeting the JVM, instances of this class are represented as short[].

class ShortArray(size: Int)

An array of shorts. When targeting the JVM, instances of this class are represented as short[].

class ShortArray

An array of shorts.

SinceKotlin

@Target(allowedTargets = [AnnotationTarget.CLASS, AnnotationTarget.PROPERTY, AnnotationTarget.FIELD, AnnotationTarget.CONSTRUCTOR, AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY_GETTER, AnnotationTarget.PROPERTY_SETTER, AnnotationTarget.TYPEALIAS])

annotation class SinceKotlin(val version: String)

Specifies the first version of Kotlin where a declaration has appeared. Using the declaration and specifying an older API version (via the -api-version command line option) will result in an error.

annotation class SinceKotlin(val version: String)

Specifies the first version of Kotlin where a declaration has appeared. Using the declaration and specifying an older API version (via the -api-version command line option) will result in an error.

annotation class SinceKotlin(val version: String)

Specifies the first version of Kotlin where a declaration has appeared. Using the declaration and specifying an older API version (via the -api-version command line option) will result in an error.

String

class String : Comparable<String> , CharSequence

The String class represents character strings. All string literals in Kotlin programs, such as "abc", are implemented as instances of this class.

class String : Comparable<String> , CharSequence

The String class represents character strings. All string literals in Kotlin programs, such as "abc", are implemented as instances of this class.

class String : Comparable<String> , CharSequence

Suppress

@Target(allowedTargets = [AnnotationTarget.CLASS, AnnotationTarget.ANNOTATION_CLASS, AnnotationTarget.TYPE_PARAMETER, AnnotationTarget.PROPERTY, AnnotationTarget.FIELD, AnnotationTarget.LOCAL_VARIABLE, AnnotationTarget.VALUE_PARAMETER, AnnotationTarget.CONSTRUCTOR, AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY_GETTER, AnnotationTarget.PROPERTY_SETTER, AnnotationTarget.TYPE, AnnotationTarget.EXPRESSION, AnnotationTarget.FILE, AnnotationTarget.TYPEALIAS])

annotation class Suppress(val names: String)

Suppresses the given compilation warnings in the annotated element.

annotation class Suppress(val names: String)

Suppresses the given compilation warnings in the annotated element.

annotation class Suppress(val names: String)

Suppresses the given compilation warnings in the annotated element.

Throwable

open class Throwable(val message: String?, val cause: Throwable?)

The base class for all errors and exceptions. Only instances of this class can be thrown or caught.

open class Throwable(val message: String?, val cause: Throwable?)

The base class for all errors and exceptions. Only instances of this class can be thrown or caught.

open class Throwable(val message: String?, val cause: Throwable?)

The base class for all errors and exceptions. Only instances of this class can be thrown or caught.

Throws

@Target(allowedTargets = [AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY_GETTER, AnnotationTarget.PROPERTY_SETTER, AnnotationTarget.CONSTRUCTOR])

expect annotation class Throws(val exceptionClasses: KClass<out Throwable>)

This annotation indicates what exceptions should be declared by a function when compiled to a platform method in Kotlin/JVM and Kotlin/Native.

Since Kotlin 1.4

actual typealias Throws = Throws

@Target(allowedTargets = [AnnotationTarget.FUNCTION, AnnotationTarget.CONSTRUCTOR])

actual annotation class Throws(val exceptionClasses: KClass<out Throwable>)

This annotation indicates what exceptions should be declared by a function when compiled to a platform method.

Since Kotlin 1.4

Triple

data class Triple<out A, out B, out C>( val first: A, val second: B, val third: C) : Serializable

Represents a triad of values

TypeCastException

open class TypeCastException : ClassCastException

UByte

value class UByte : Comparable<UByte>

UByteArray

value class UByteArray : Collection<UByte>

UInt

value class UInt : Comparable<UInt>

UIntArray

value class UIntArray : Collection<UInt>

ULong

value class ULong : Comparable<ULong>

ULongArray

UninitializedPropertyAccessException

value class ULongArray : Collection<ULong>

expect class ~~UninitializedPropertyAccessException~~(message: String?, cause: Throwable?) : RuntimeException

actual class UninitializedPropertyAccessException(message: String?, cause: Throwable?) : RuntimeException

actual open class UninitializedPropertyAccessException(val message: String?, val cause: Throwable?) : RuntimeException

Unit

object Unit

The type with only one value: the Unit object. This type corresponds to the void type in Java.

object Unit

The type with only one value: the Unit object. This type corresponds to the void type in Java.

object Unit

The type with only one value: the Unit object. This type corresponds to the void type in Java.

object Unit

The type with only one value: the Unit object.

UnsafeVariance

@Target(allowedTargets = [AnnotationTarget.TYPE])

annotation class UnsafeVariance

Suppresses errors about variance conflict

@Target(allowedTargets = [AnnotationTarget.TYPE])

annotation class UnsafeVariance

Suppresses errors about variance conflict

@Target(allowedTargets = [AnnotationTarget.TYPE])

annotation class UnsafeVariance

Suppresses errors about variance conflict

UnsupportedOperationException

expect open class UnsupportedOperationException(message: String?, cause: Throwable?) : RuntimeException

actual typealias UnsupportedOperationException = UnsupportedOperationException

actual open class UnsupportedOperationException(val message: String?, val cause: Throwable?) : RuntimeException

UseExperimental

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

Allows to use experimental API denoted by the given markers in the annotated file, declaration, or expression. If a declaration is annotated with UseExperimental, its usages are not required to opt-in to that experimental API.

Since Kotlin 1.2

UShort

value class UShort : Comparable<UShort>

UShortArray

value class UShortArray : Collection<UShort>

Functions

addSuppressed

expect fun Throwable.addSuppressed(exception: Throwable)

When supported by the platform, adds the specified exception to the list of exceptions that were suppressed in order to deliver this exception.

Since Kotlin 1.4

actual fun Throwable.addSuppressed(exception: Throwable)

When supported by the platform, adds the specified exception to the list of exceptions that were suppressed in order to deliver this exception.

Since Kotlin 1.1

actual fun Throwable.addSuppressed(exception: Throwable)

Adds the specified exception to the list of exceptions that were suppressed in order to deliver this exception.

Since Kotlin 1.4

actual fun Throwable.addSuppressed(exception: Throwable)

Adds the specified exception to the list of exceptions that were suppressed in order to deliver this exception.

Since Kotlin 1.4

also

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

Calls the specified function block with this value as its argument and returns this value.

Since Kotlin 1.1

and

infix inline fun BigInteger.and(other: BigInteger): BigInteger

Performs a bitwise AND operation between the two values.

Since Kotlin 1.2

apply

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

Calls the specified function block with this value as its receiver and returns this value.

arrayOf

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

Returns an array containing the specified elements.

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

Returns an array containing the specified elements.

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

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

Returns an array containing the specified elements.

arrayOfNulls

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

Returns an array of objects of the given type with the given size, initialized with null values.

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

Returns an array of objects of the given type with the given size, initialized with null values.

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

Returns an array of objects of the given type with the given size, initialized with null values.

assert

inline fun assert(value: Boolean)

Throws an AssertionError if the value is false and runtime assertions have been enabled on the JVM using the -ea JVM option.

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

Throws an AssertionError calculated by lazyMessage if the value is false and runtime assertions have been enabled on the JVM using the -ea JVM option.

inline fun assert(value: Boolean)

Throws an AssertionError if the value is false and runtime assertions have been enabled during compilation.

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

Throws an AssertionError calculated by lazyMessage if the value is false and runtime assertions have been enabled during compilation.

booleanArrayOf

fun booleanArrayOf(vararg elements: Boolean): BooleanArray

Returns an array containing the specified boolean values.

fun booleanArrayOf(vararg elements: Boolean): BooleanArray

Returns an array containing the specified boolean values.

fun booleanArrayOf(vararg elements: Boolean): BooleanArray

inline fun booleanArrayOf(vararg elements: Boolean): BooleanArray

Returns an array containing the specified boolean values.

byteArrayOf

fun byteArrayOf(vararg elements: Byte): ByteArray

Returns an array containing the specified Byte numbers.

fun byteArrayOf(vararg elements: Byte): ByteArray

Returns an array containing the specified Byte numbers.

fun byteArrayOf(vararg elements: Byte): ByteArray

inline fun byteArrayOf(vararg elements: Byte): ByteArray

Returns an array containing the specified Byte numbers.

Char

inline fun Char(code: Int): Char

Creates a Char with the specified code, or throws an exception if the code is out of Char.MIN_VALUE.code..Char.MAX_VALUE.code.

Since Kotlin 1.5

expect fun Char(code: UShort): Char

Creates a Char with the specified code.

Since Kotlin 1.5

actual inline fun Char(code: UShort): Char

Creates a Char with the specified code.

Since Kotlin 1.5

actual inline fun Char(code: UShort): Char

Creates a Char with the specified code.

Since Kotlin 1.5

actual inline fun Char(code: UShort): Char

Creates a Char with the specified code.

Since Kotlin 1.5

charArrayOf

fun charArrayOf(vararg elements: Char): CharArray

Returns an array containing the specified characters.

fun charArrayOf(vararg elements: Char): CharArray

Returns an array containing the specified characters.

fun charArrayOf(vararg elements: Char): CharArray

inline fun charArrayOf(vararg elements: Char): CharArray

Returns an array containing the specified characters.

check

inline fun check(value: Boolean)

Throws an IllegalStateException if the value is false.

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

Throws an IllegalStateException with the result of calling lazyMessage if the value is false.

checkNotNull

inline fun <T : Any> checkNotNull(value: T?): T

Throws an IllegalStateException if the value is null. Otherwise returns the not null value.

inline fun <T : Any> checkNotNull(value: T?, lazyMessage: () -> Any): T

Throws an IllegalStateException with the result of calling lazyMessage if the value is null. Otherwise returns the not null value.

countLeadingZeroBits

inline fun Byte.countLeadingZeroBits(): Int

Counts the number of consecutive most significant bits that are zero in the binary representation of this Byte number.

Since Kotlin 1.4

expect fun Int.countLeadingZeroBits(): Int

Counts the number of consecutive most significant bits that are zero in the binary representation of this Int number.

Since Kotlin 1.4

expect fun Long.countLeadingZeroBits(): Int

Counts the number of consecutive most significant bits that are zero in the binary representation of this Long number.

Since Kotlin 1.4

inline fun Short.countLeadingZeroBits(): Int

Counts the number of consecutive most significant bits that are zero in the binary representation of this Short number.

Since Kotlin 1.4

inline fun UByte.countLeadingZeroBits(): Int

Counts the number of consecutive most significant bits that are zero in the binary representation of this UByte number.

Since Kotlin 1.5

inline fun UInt.countLeadingZeroBits(): Int

Counts the number of consecutive most significant bits that are zero in the binary representation of this UInt number.

Since Kotlin 1.5

inline fun ULong.countLeadingZeroBits(): Int

Counts the number of consecutive most significant bits that are zero in the binary representation of this ULong number.

Since Kotlin 1.5

inline fun UShort.countLeadingZeroBits(): Int

Counts the number of consecutive most significant bits that are zero in the binary representation of this UShort number.

Since Kotlin 1.5

actual inline fun Int.countLeadingZeroBits(): Int

Counts the number of consecutive most significant bits that are zero in the binary representation of this Int number.

Since Kotlin 1.4

actual inline fun Long.countLeadingZeroBits(): Int

Counts the number of consecutive most significant bits that are zero in the binary representation of this Long number.

Since Kotlin 1.4

actual inline fun Int.countLeadingZeroBits(): Int

Counts the number of consecutive most significant bits that are zero in the binary representation of this Int number.

Since Kotlin 1.4

actual fun Long.countLeadingZeroBits(): Int

Counts the number of consecutive most significant bits that are zero in the binary representation of this Long number.

Since Kotlin 1.4

actual fun Int.countLeadingZeroBits(): Int

Counts the number of consecutive most significant bits that are zero in the binary representation of this Int number.

Since Kotlin 1.4

actual fun Long.countLeadingZeroBits(): Int

Counts the number of consecutive most significant bits that are zero in the binary representation of this Long number.

Since Kotlin 1.4

countOneBits

inline fun Byte.countOneBits(): Int

Counts the number of set bits in the binary representation of this Byte number.

Since Kotlin 1.4

expect fun Int.countOneBits(): Int

Counts the number of set bits in the binary representation of this Int number.

Since Kotlin 1.4

expect fun Long.countOneBits(): Int

Counts the number of set bits in the binary representation of this Long number.

Since Kotlin 1.4

inline fun Short.countOneBits(): Int

Counts the number of set bits in the binary representation of this Short number.

Since Kotlin 1.4

inline fun UByte.countOneBits(): Int

Counts the number of set bits in the binary representation of this UByte number.

Since Kotlin 1.5

inline fun UInt.countOneBits(): Int

Counts the number of set bits in the binary representation of this UInt number.

Since Kotlin 1.5

inline fun ULong.countOneBits(): Int

Counts the number of set bits in the binary representation of this ULong number.

Since Kotlin 1.5

inline fun UShort.countOneBits(): Int

Counts the number of set bits in the binary representation of this UShort number.

Since Kotlin 1.5

actual inline fun Int.countOneBits(): Int

Counts the number of set bits in the binary representation of this Int number.

Since Kotlin 1.4

actual inline fun Long.countOneBits(): Int

Counts the number of set bits in the binary representation of this Long number.

Since Kotlin 1.4

actual fun Int.countOneBits(): Int

Counts the number of set bits in the binary representation of this Int number.

Since Kotlin 1.4

actual fun Long.countOneBits(): Int

Counts the number of set bits in the binary representation of this Long number.

Since Kotlin 1.4

actual external fun Int.countOneBits(): Int

Counts the number of set bits in the binary representation of this Int number.

Since Kotlin 1.4

actual external fun Long.countOneBits(): Int

Counts the number of set bits in the binary representation of this Long number.

Since Kotlin 1.4

countTrailingZeroBits

inline fun Byte.countTrailingZeroBits(): Int

Counts the number of consecutive least significant bits that are zero in the binary representation of this Byte number.

Since Kotlin 1.4

expect fun Int.countTrailingZeroBits(): Int

Counts the number of consecutive least significant bits that are zero in the binary representation of this Int number.

Since Kotlin 1.4

expect fun Long.countTrailingZeroBits(): Int

Counts the number of consecutive least significant bits that are zero in the binary representation of this Long number.

Since Kotlin 1.4

inline fun Short.countTrailingZeroBits(): Int

Counts the number of consecutive least significant bits that are zero in the binary representation of this Short number.

Since Kotlin 1.4

inline fun UByte.countTrailingZeroBits(): Int

Counts the number of consecutive least significant bits that are zero in the binary representation of this UByte number.

Since Kotlin 1.5

inline fun UInt.countTrailingZeroBits(): Int

Counts the number of consecutive least significant bits that are zero in the binary representation of this UInt number.

Since Kotlin 1.5

inline fun ULong.countTrailingZeroBits(): Int

Counts the number of consecutive least significant bits that are zero in the binary representation of this ULong number.

Since Kotlin 1.5

inline fun UShort.countTrailingZeroBits(): Int

Counts the number of consecutive least significant bits that are zero in the binary representation of this UShort number.

Since Kotlin 1.5

actual inline fun Int.countTrailingZeroBits(): Int

Counts the number of consecutive least significant bits that are zero in the binary representation of this Int number.

Since Kotlin 1.4

actual inline fun Long.countTrailingZeroBits(): Int

Counts the number of consecutive least significant bits that are zero in the binary representation of this Long number.

Since Kotlin 1.4

actual fun Int.countTrailingZeroBits(): Int

Counts the number of consecutive least significant bits that are zero in the binary representation of this Int number.

Since Kotlin 1.4

actual fun Long.countTrailingZeroBits(): Int

Counts the number of consecutive least significant bits that are zero in the binary representation of this Long number.

Since Kotlin 1.4

actual fun Int.countTrailingZeroBits(): Int

Counts the number of consecutive least significant bits that are zero in the binary representation of this Int number.

Since Kotlin 1.4

actual fun Long.countTrailingZeroBits(): Int

Counts the number of consecutive least significant bits that are zero in the binary representation of this Long number.

Since Kotlin 1.4

dec

inline operator fun BigDecimal.dec(): BigDecimal

Enables the use of the unary -- operator for BigDecimal instances.

Since Kotlin 1.2

inline operator fun BigInteger.dec(): BigInteger

Enables the use of the -- operator for BigInteger instances.

Since Kotlin 1.2

div

inline operator fun BigDecimal.div(other: BigDecimal): BigDecimal

Enables the use of the / operator for BigDecimal instances.

inline operator fun BigInteger.div(other: BigInteger): BigInteger

Enables the use of the / operator for BigInteger instances.

doubleArrayOf

fun doubleArrayOf(vararg elements: Double): DoubleArray

Returns an array containing the specified Double numbers.

fun doubleArrayOf(vararg elements: Double): DoubleArray

Returns an array containing the specified Double numbers.

fun doubleArrayOf(vararg elements: Double): DoubleArray

inline fun doubleArrayOf(vararg elements: Double): DoubleArray

Returns an array containing the specified Double numbers.

emptyArray

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

Returns an empty array of the specified type T.

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

Returns an empty array of the specified type T.

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

Returns an empty array of the specified type T.

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

enumValueOf

inline fun <T : Enum<T>> enumValueOf(name: String): T

Returns an enum entry with specified name.

Since Kotlin 1.1

inline fun <T : Enum<T>> enumValueOf(name: String): T

Returns an enum entry with specified name.

Since Kotlin 1.1

inline fun <T : Enum<T>> enumValueOf(name: String): T

Returns an enum entry with specified name.

enumValues

inline fun <T : Enum<T>> enumValues(): Array<T>

Returns an array containing enum T entries.

Since Kotlin 1.1

inline fun <T : Enum<T>> enumValues(): Array<T>

Returns an array containing enum T entries.

Since Kotlin 1.1

inline fun <T : Enum<T>> enumValues(): Array<T>

Returns an array containing enum T entries.

error

inline fun error(message: Any): Nothing

Throws an IllegalStateException with the given message.

floatArrayOf

fun floatArrayOf(vararg elements: Float): FloatArray

Returns an array containing the specified Float numbers.

fun floatArrayOf(vararg elements: Float): FloatArray

Returns an array containing the specified Float numbers.

fun floatArrayOf(vararg elements: Float): FloatArray

inline fun floatArrayOf(vararg elements: Float): FloatArray

Returns an array containing the specified Float numbers.

floorDiv

inline fun Byte.floorDiv(other: Byte): Int

inline fun Byte.floorDiv(other: Int): Int

inline fun Byte.floorDiv(other: Long): Long

inline fun Byte.floorDiv(other: Short): Int

inline fun Int.floorDiv(other: Byte): Int

inline fun Int.floorDiv(other: Int): Int

inline fun Int.floorDiv(other: Long): Long

inline fun Int.floorDiv(other: Short): Int

inline fun Long.floorDiv(other: Byte): Long

inline fun Long.floorDiv(other: Int): Long

inline fun Long.floorDiv(other: Long): Long

inline fun Long.floorDiv(other: Short): Long

inline fun Short.floorDiv(other: Byte): Int

inline fun Short.floorDiv(other: Int): Int

inline fun Short.floorDiv(other: Long): Long

inline fun Short.floorDiv(other: Short): Int

Divides this value by the other value, flooring the result to an integer that is closer to negative infinity.

Since Kotlin 1.5

fold

inline fun <R, T> Result<T>.fold(onSuccess: (value: T) -> R, onFailure: (exception: Throwable) -> R): R

Returns the result of onSuccess for the encapsulated value if this instance represents success or the result of onFailure function for the encapsulated Throwable exception if it is failure.

Since Kotlin 1.3

fromBits

expect fun Double.Companion.fromBits(bits: Long): Double

Returns the Double value corresponding to a given bit representation.

Since Kotlin 1.2

expect fun Float.Companion.fromBits(bits: Int): Float

Returns the Float value corresponding to a given bit representation.

Since Kotlin 1.2

actual inline fun Double.Companion.fromBits(bits: Long): Double

Returns the Double value corresponding to a given bit representation.

Since Kotlin 1.2

actual inline fun Float.Companion.fromBits(bits: Int): Float

Returns the Float value corresponding to a given bit representation.

Since Kotlin 1.2

actual inline fun Double.Companion.fromBits(bits: Long): Double

Returns the Double value corresponding to a given bit representation.

Since Kotlin 1.2

actual inline fun Float.Companion.fromBits(bits: Int): Float

Returns the Float value corresponding to a given bit representation.

Since Kotlin 1.2

actual inline fun Double.Companion.fromBits(bits: Long): Double

Returns the Double value corresponding to a given bit representation.

Since Kotlin 1.2

actual inline fun Float.Companion.fromBits(bits: Int): Float

Returns the Float value corresponding to a given bit representation.

Since Kotlin 1.2

getOrDefault

inline fun <R, T : R> Result<T>.getOrDefault(defaultValue: R): R

Returns the encapsulated value if this instance represents success or the defaultValue if it is failure.

Since Kotlin 1.3

getOrElse

inline fun <R, T : R> Result<T>.getOrElse(onFailure: (exception: Throwable) -> R): R

Returns the encapsulated value if this instance represents success or the result of onFailure function for the encapsulated Throwable exception if it is failure.

Since Kotlin 1.3

getOrThrow

inline fun <T> Result<T>.getOrThrow(): T

Returns the encapsulated value if this instance represents success or throws the encapsulated Throwable exception if it is failure.

Since Kotlin 1.3

getValue

inline operator fun <T> Lazy<T>.getValue(thisRef: Any?, property: KProperty<*>): T

An extension to delegate a read-only property of type T to an instance of Lazy.

inline operator fun <V> KProperty0<V>.getValue(thisRef: Any?, property: KProperty<*>): V

An extension operator that allows delegating a read-only property of type V to a property reference to a property of type V or its subtype.

Since Kotlin 1.4

inline operator fun <T, V> KProperty1<T, V>.getValue(thisRef: T, property: KProperty<*>): V

An extension operator that allows delegating a read-only member or extension property of type V to a property reference to a member or extension property of type V or its subtype.

Since Kotlin 1.4

hashCode

inline fun Any?.hashCode(): Int

Returns a hash code value for the object or zero if the object is null.

Since Kotlin 1.3

inc

inline operator fun BigDecimal.inc(): BigDecimal

Enables the use of the unary ++ operator for BigDecimal instances.

Since Kotlin 1.2

inline operator fun BigInteger.inc(): BigInteger

Enables the use of the ++ operator for BigInteger instances.

Since Kotlin 1.2

intArrayOf

fun intArrayOf(vararg elements: Int): IntArray

Returns an array containing the specified Int numbers.

fun intArrayOf(vararg elements: Int): IntArray

Returns an array containing the specified Int numbers.

fun intArrayOf(vararg elements: Int): IntArray

inline fun intArrayOf(vararg elements: Int): IntArray

Returns an array containing the specified Int numbers.

inv

inline fun BigInteger.inv(): BigInteger

Inverts the bits including the sign bit in this value.

Since Kotlin 1.2

invoke

operator fun <T, R> DeepRecursiveFunction<T, R>.invoke(value: T): R

Initiates a call to this deep recursive function, forming a root of the call tree.

Since Kotlin 1.4

isFinite

expect fun Double.isFinite(): Boolean

expect fun Float.isFinite(): Boolean

actual inline fun Double.isFinite(): Boolean

actual inline fun Float.isFinite(): Boolean

Returns true if the argument is a finite floating-point value; returns false otherwise (for NaN and infinity arguments).

actual fun Double.isFinite(): Boolean

actual fun Float.isFinite(): Boolean

Returns true if the argument is a finite floating-point value; returns false otherwise (for NaN and infinity arguments).

actual external fun Double.isFinite(): Boolean

actual external fun Float.isFinite(): Boolean

Returns true if the argument is a finite floating-point value; returns false otherwise (for NaN and infinity arguments).

isInfinite

expect fun Double.isInfinite(): Boolean

expect fun Float.isInfinite(): Boolean

actual inline fun Double.isInfinite(): Boolean

actual inline fun Float.isInfinite(): Boolean

Returns true if this value is infinitely large in magnitude.

actual fun Double.isInfinite(): Boolean

actual fun Float.isInfinite(): Boolean

Returns true if this value is infinitely large in magnitude.

actual external fun Double.isInfinite(): Boolean

actual external fun Float.isInfinite(): Boolean

Returns true if this value is infinitely large in magnitude.

isNaN

expect fun Double.isNaN(): Boolean

expect fun Float.isNaN(): Boolean

actual inline fun Double.isNaN(): Boolean

actual inline fun Float.isNaN(): Boolean

Returns true if the specified number is a Not-a-Number (NaN) value, false otherwise.

actual fun Double.isNaN(): Boolean

actual fun Float.isNaN(): Boolean

Returns true if the specified number is a Not-a-Number (NaN) value, false otherwise.

actual external fun Double.isNaN(): Boolean

actual external fun Float.isNaN(): Boolean

Returns true if the specified number is a Not-a-Number (NaN) value, false otherwise.

lazy

expect fun <T> lazy(initializer: () -> T): Lazy<T>

expect fun <T> lazy(lock: Any?, initializer: () -> T): Lazy<T>

expect fun <T> lazy(mode: LazyThreadSafetyMode, initializer: () -> T): Lazy<T>

Creates a new instance of the Lazy that uses the specified initialization function initializer.

actual fun <T> lazy(initializer: () -> T): Lazy<T>

actual fun <T> lazy(lock: Any?, initializer: () -> T): Lazy<T>

Creates a new instance of the Lazy that uses the specified initialization function initializer and the default thread-safety mode LazyThreadSafetyMode.SYNCHRONIZED.

actual fun <T> lazy(mode: LazyThreadSafetyMode, initializer: () -> T): Lazy<T>

Creates a new instance of the Lazy that uses the specified initialization function initializer and thread-safety mode.

actual fun <T> lazy(initializer: () -> T): Lazy<T>

actual fun <T> lazy(lock: Any?, initializer: () -> T): Lazy<T>

actual fun <T> lazy(mode: LazyThreadSafetyMode, initializer: () -> T): Lazy<T>

Creates a new instance of the Lazy that uses the specified initialization function initializer.

actual fun <T> lazy(initializer: () -> T): Lazy<T>

actual fun <T> lazy(lock: Any?, initializer: () -> T): Lazy<T>

Creates a new instance of the Lazy that uses the specified initialization function initializer and the default thread-safety mode LazyThreadSafetyMode.SYNCHRONIZED.

actual fun <T> lazy(mode: LazyThreadSafetyMode, initializer: () -> T): Lazy<T>

Creates a new instance of the Lazy that uses the specified initialization function initializer and thread-safety mode.

lazyOf

fun <T> lazyOf(value: T): Lazy<T>

Creates a new instance of the Lazy that is already initialized with the specified value.

let

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

Calls the specified function block with this value as its argument and returns its result.

longArrayOf

fun longArrayOf(vararg elements: Long): LongArray

Returns an array containing the specified Long numbers.

fun longArrayOf(vararg elements: Long): LongArray

Returns an array containing the specified Long numbers.

fun longArrayOf(vararg elements: Long): LongArray

inline fun longArrayOf(vararg elements: Long): LongArray

Returns an array containing the specified Long numbers.

map

inline fun <R, T> Result<T>.map(transform: (value: T) -> R): Result<R>

Returns the encapsulated result of the given transform function applied to the encapsulated value if this instance represents success or the original encapsulated Throwable exception if it is failure.

Since Kotlin 1.3

mapCatching

inline fun <R, T> Result<T>.mapCatching(transform: (value: T) -> R): Result<R>

Since Kotlin 1.3

minus

inline operator fun BigDecimal.minus(other: BigDecimal): BigDecimal

Enables the use of the - operator for BigDecimal instances.

inline operator fun BigInteger.minus(other: BigInteger): BigInteger

Enables the use of the - operator for BigInteger instances.

mod

inline fun Byte.mod(other: Byte): Byte

inline fun Byte.mod(other: Int): Int

inline fun Byte.mod(other: Long): Long

inline fun Byte.mod(other: Short): Short

inline fun Double.mod(other: Double): Double

inline fun Double.mod(other: Float): Double

inline fun Float.mod(other: Double): Double

inline fun Float.mod(other: Float): Float

inline fun Int.mod(other: Byte): Byte

inline fun Int.mod(other: Int): Int

inline fun Int.mod(other: Long): Long

inline fun Int.mod(other: Short): Short

inline fun Long.mod(other: Byte): Byte

inline fun Long.mod(other: Int): Int

inline fun Long.mod(other: Long): Long

inline fun Long.mod(other: Short): Short

inline fun Short.mod(other: Byte): Byte

inline fun Short.mod(other: Int): Int

inline fun Short.mod(other: Long): Long

inline fun Short.mod(other: Short): Short

Calculates the remainder of flooring division of this value by the other value.

Since Kotlin 1.5

onFailure

inline fun <T> Result<T>.onFailure(action: (exception: Throwable) -> Unit): Result<T>

Performs the given action on the encapsulated Throwable exception if this instance represents failure. Returns the original Result unchanged.

Since Kotlin 1.3

onSuccess

inline fun <T> Result<T>.onSuccess(action: (value: T) -> Unit): Result<T>

Performs the given action on the encapsulated value if this instance represents success. Returns the original Result unchanged.

Since Kotlin 1.3

infix inline fun BigInteger.or(other: BigInteger): BigInteger

Performs a bitwise OR operation between the two values.

Since Kotlin 1.2

plus

operator fun String?.plus(other: Any?): String

Concatenates this string with the string representation of the given other object. If either the receiver or the other object are null, they are represented as the string "null".

inline operator fun BigDecimal.plus(other: BigDecimal): BigDecimal

Enables the use of the + operator for BigDecimal instances.

inline operator fun BigInteger.plus(other: BigInteger): BigInteger

Enables the use of the + operator for BigInteger instances.

operator fun String?.plus(other: Any?): String

Concatenates this string with the string representation of the given other object. If either the receiver or the other object are null, they are represented as the string "null".

inline operator fun String?.plus(other: Any?): String

printStackTrace

expect fun Throwable.printStackTrace()

Prints the detailed description of this throwable to the standard output or standard error output.

Since Kotlin 1.4

actual inline fun Throwable.printStackTrace()

Prints the detailed description of this throwable to the standard error output.

inline fun Throwable.printStackTrace(stream: PrintStream)

Prints the detailed description of this throwable to the specified stream.

inline fun Throwable.printStackTrace(writer: PrintWriter)

Prints the detailed description of this throwable to the specified writer.

actual fun Throwable.printStackTrace()

Prints the detailed description of this throwable to console error output.

Since Kotlin 1.4

actual inline fun Throwable.printStackTrace()

Prints the detailed description of this throwable to the standard output.

Since Kotlin 1.4

recover

inline fun <R, T : R> Result<T>.recover(transform: (exception: Throwable) -> R): Result<R>

Returns the encapsulated result of the given transform function applied to the encapsulated Throwable exception if this instance represents failure or the original encapsulated value if it is success.

Since Kotlin 1.3

recoverCatching

inline fun <R, T : R> Result<T>.recoverCatching(transform: (exception: Throwable) -> R): Result<R>

Since Kotlin 1.3

rem

inline operator fun BigDecimal.rem(other: BigDecimal): BigDecimal

Enables the use of the % operator for BigDecimal instances.

inline operator fun BigInteger.rem(other: BigInteger): BigInteger

Enables the use of the % operator for BigInteger instances.

Since Kotlin 1.1

repeat

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

Executes the given function action specified number of times.

require

inline fun require(value: Boolean)

Throws an IllegalArgumentException if the value is false.

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

Throws an IllegalArgumentException with the result of calling lazyMessage if the value is false.

requireNotNull

inline fun <T : Any> requireNotNull(value: T?): T

Throws an IllegalArgumentException if the value is null. Otherwise returns the not null value.

inline fun <T : Any> requireNotNull(value: T?, lazyMessage: () -> Any): T

Throws an IllegalArgumentException with the result of calling lazyMessage if the value is null. Otherwise returns the not null value.

rotateLeft

fun Byte.rotateLeft(bitCount: Int): Byte

Rotates the binary representation of this Byte number left by the specified bitCount number of bits. The most significant bits pushed out from the left side reenter the number as the least significant bits on the right side.

Since Kotlin 1.3

expect fun Int.rotateLeft(bitCount: Int): Int

Rotates the binary representation of this Int number left by the specified bitCount number of bits. The most significant bits pushed out from the left side reenter the number as the least significant bits on the right side.

Since Kotlin 1.3

expect fun Long.rotateLeft(bitCount: Int): Long

Rotates the binary representation of this Long number left by the specified bitCount number of bits. The most significant bits pushed out from the left side reenter the number as the least significant bits on the right side.

Since Kotlin 1.3

fun Short.rotateLeft(bitCount: Int): Short

Rotates the binary representation of this Short number left by the specified bitCount number of bits. The most significant bits pushed out from the left side reenter the number as the least significant bits on the right side.

Since Kotlin 1.3

inline fun UByte.rotateLeft(bitCount: Int): UByte

Rotates the binary representation of this UByte number left by the specified bitCount number of bits. The most significant bits pushed out from the left side reenter the number as the least significant bits on the right side.

Since Kotlin 1.3

inline fun UInt.rotateLeft(bitCount: Int): UInt

Rotates the binary representation of this UInt number left by the specified bitCount number of bits. The most significant bits pushed out from the left side reenter the number as the least significant bits on the right side.

Since Kotlin 1.3

inline fun ULong.rotateLeft(bitCount: Int): ULong

Rotates the binary representation of this ULong number left by the specified bitCount number of bits. The most significant bits pushed out from the left side reenter the number as the least significant bits on the right side.

Since Kotlin 1.3

inline fun UShort.rotateLeft(bitCount: Int): UShort

Rotates the binary representation of this UShort number left by the specified bitCount number of bits. The most significant bits pushed out from the left side reenter the number as the least significant bits on the right side.

Since Kotlin 1.3

@ExperimentalStdlibApi

actual inline fun Int.rotateLeft(bitCount: Int): Int

Since Kotlin 1.3

@ExperimentalStdlibApi

actual inline fun Long.rotateLeft(bitCount: Int): Long

Since Kotlin 1.3

@ExperimentalStdlibApi

actual fun Int.rotateLeft(bitCount: Int): Int

Since Kotlin 1.3

@ExperimentalStdlibApi

actual fun Long.rotateLeft(bitCount: Int): Long

Since Kotlin 1.3

@ExperimentalStdlibApi

actual fun Int.rotateLeft(bitCount: Int): Int

Since Kotlin 1.3

@ExperimentalStdlibApi

actual fun Long.rotateLeft(bitCount: Int): Long

Since Kotlin 1.3

rotateRight

fun Byte.rotateRight(bitCount: Int): Byte

Rotates the binary representation of this Byte number right by the specified bitCount number of bits. The least significant bits pushed out from the right side reenter the number as the most significant bits on the left side.

Since Kotlin 1.3

expect fun Int.rotateRight(bitCount: Int): Int

Rotates the binary representation of this Int number right by the specified bitCount number of bits. The least significant bits pushed out from the right side reenter the number as the most significant bits on the left side.

Since Kotlin 1.3

expect fun Long.rotateRight(bitCount: Int): Long

Rotates the binary representation of this Long number right by the specified bitCount number of bits. The least significant bits pushed out from the right side reenter the number as the most significant bits on the left side.

Since Kotlin 1.3

fun Short.rotateRight(bitCount: Int): Short

Rotates the binary representation of this Short number right by the specified bitCount number of bits. The least significant bits pushed out from the right side reenter the number as the most significant bits on the left side.

Since Kotlin 1.3

inline fun UByte.rotateRight(bitCount: Int): UByte

Rotates the binary representation of this UByte number right by the specified bitCount number of bits. The least significant bits pushed out from the right side reenter the number as the most significant bits on the left side.

Since Kotlin 1.3

inline fun UInt.rotateRight(bitCount: Int): UInt

Rotates the binary representation of this UInt number right by the specified bitCount number of bits. The least significant bits pushed out from the right side reenter the number as the most significant bits on the left side.

Since Kotlin 1.3

inline fun ULong.rotateRight(bitCount: Int): ULong

Rotates the binary representation of this ULong number right by the specified bitCount number of bits. The least significant bits pushed out from the right side reenter the number as the most significant bits on the left side.

Since Kotlin 1.3