Core functions and types, available on all supported platforms.
Base interface implicitly implemented by all annotation interfaces. See Kotlin language documentation for more information on annotations.
interface Annotation
The root of the Kotlin class hierarchy. Every Kotlin class has Any as a superclass.
open class Any
Represents an array (specifically, a Java array when targeting the JVM platform). Array instances can be created using the arrayOf, arrayOfNulls and emptyArray standard library functions. See Kotlin language documentation for more information on arrays.
class Array<T>
open class ArrayIndexOutOfBoundsException : IndexOutOfBoundsException
Represents a value which is either true
or false
. On the JVM, non-nullable values of this type are represented as values of the primitive type boolean
.
class Boolean : Comparable<Boolean>
An array of booleans. When targeting the JVM, instances of this class are represented as boolean[]
.
class BooleanArray
Represents a 8-bit signed integer. On the JVM, non-nullable values of this type are represented as values of the primitive type byte
.
class Byte : Number, Comparable<Byte>
An array of bytes. When targeting the JVM, instances of this class are represented as byte[]
.
class ByteArray
Represents a 16-bit Unicode character.
class Char : Comparable<Char>
An array of chars. When targeting the JVM, instances of this class are represented as char[]
.
class CharArray
Represents a readable sequence of Char values.
interface CharSequence
Classes which inherit from this interface have a defined total ordering between their instances.
interface Comparable<in T>
Provides a comparison function for imposing a total ordering between instances of the type T.
fun interface Comparator<T>
typealias Comparator<T> = Comparator<T>
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.
class DeepRecursiveFunction<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.
sealed class DeepRecursiveScope<T, R>
Possible levels of a deprecation. The level specifies how the deprecated element usages are reported in code.
enum class DeprecationLevel
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>
An array of doubles. When targeting the JVM, instances of this class are represented as double[]
.
class DoubleArray
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>> : Comparable<E>
class Enum<T : Enum<T>> : Comparable<Enum<T>>
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>
An array of floats. When targeting the JVM, instances of this class are represented as float[]
.
class FloatArray
Represents a value of a functional type, such as a lambda, an anonymous function or a function reference.
interface Function<out R>
open class IllegalCharacterConversionException : IllegalArgumentException
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>
An array of ints. When targeting the JVM, instances of this class are represented as int[]
.
class IntArray
Represents a version of the Kotlin standard library.
class KotlinVersion : Comparable<KotlinVersion>
Represents a value with lazy initialization.
interface Lazy<out T>
Specifies how a Lazy instance synchronizes initialization among multiple threads.
enum class LazyThreadSafetyMode
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>
An array of longs. When targeting the JVM, instances of this class are represented as long[]
.
class LongArray
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
Superclass for all platform classes representing numeric values.
abstract class Number
open class OutOfMemoryError : Error
Represents a generic pair of two values.
data class Pair<out A, out B> : Serializable
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>
An array of shorts. When targeting the JVM, instances of this class are represented as short[]
.
class ShortArray
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 base class for all errors and exceptions. Only instances of this class can be thrown or caught.
open class Throwable
Represents a triad of values
data class Triple<out A, out B, out C> : Serializable
class UByte : Comparable<UByte>
class UByteArray : Collection<UByte>
class UInt : Comparable<UInt>
class UIntArray : Collection<UInt>
class ULong : Comparable<ULong>
class ULongArray : Collection<ULong>
The type with only one value: the Unit
object. This type corresponds to the void
type in Java.
object Unit
class UShort : Comparable<UShort>
class UShortArray : Collection<UShort>
Allows to infer generic type arguments of a function from the calls in the annotated function parameter of that function.
annotation class BuilderInference
Marks the annotated declaration as deprecated.
annotation class Deprecated
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.
annotation class DeprecatedSinceKotlin
When applied to annotation class X specifies that X defines a DSL language
annotation class DslMarker
Signals that the annotated annotation class is a marker of an experimental API.
annotation class Experimental
The experimental multiplatform support API marker.
annotation class ExperimentalMultiplatform
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.
annotation class ExperimentalStdlibApi
Marks the API that is dependent on the experimental unsigned types, including those types themselves.
annotation class ExperimentalUnsignedTypes
Signifies that the annotated functional type represents an extension function.
annotation class ExtensionFunctionType
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.
annotation class Metadata
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.
annotation class OptIn
Marks an expected annotation class that it isn't required to have actual counterparts in all platforms.
annotation class OptionalExpectation
Enables overload selection based on the type of the value returned from lambda argument.
annotation class OverloadResolutionByLambdaReturnType
Annotates type arguments of functional type and holds corresponding parameter name specified by the user in type declaration (if any).
annotation class ParameterName
When applied to a class or a member with internal visibility allows to use it from public inline functions and makes it effectively public.
annotation class PublishedApi
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.
annotation class ReplaceWith
Signals that the annotated annotation class is a marker of an API that requires an explicit opt-in.
annotation class RequiresOptIn
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
Suppresses the given compilation warnings in the annotated element.
annotation class Suppress
This annotation indicates what exceptions should be declared by a function when compiled to a platform method in Kotlin/JVM and Kotlin/Native.
annotation class Throws
typealias Throws = Throws
Suppresses errors about variance conflict
annotation class UnsafeVariance
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.
annotation class UseExperimental
open class ArithmeticException : RuntimeException
typealias ArithmeticException = ArithmeticException
open class AssertionError : Error
typealias AssertionError = AssertionError
open class ClassCastException : RuntimeException
typealias ClassCastException = ClassCastException
open class ConcurrentModificationException : RuntimeException
typealias ConcurrentModificationException = ConcurrentModificationException
open class Error : Throwable
typealias Error = Error
open class Exception : Throwable
typealias Exception = Exception
open class IllegalArgumentException : RuntimeException
typealias IllegalArgumentException = IllegalArgumentException
open class IllegalStateException : RuntimeException
typealias IllegalStateException = IllegalStateException
open class IndexOutOfBoundsException : RuntimeException
typealias IndexOutOfBoundsException = IndexOutOfBoundsException
open class KotlinNullPointerException : NullPointerException
open class NoSuchElementException : RuntimeException
typealias NoSuchElementException = NoSuchElementException
An exception is thrown to indicate that a method body remains to be implemented.
class NotImplementedError : Error
open class NoWhenBranchMatchedException : RuntimeException
open class NoWhenBranchMatchedException : RuntimeException
open class NullPointerException : RuntimeException
typealias NullPointerException = NullPointerException
open class NumberFormatException : IllegalArgumentException
typealias NumberFormatException = NumberFormatException
open class RuntimeException : Exception
typealias RuntimeException = RuntimeException
open class TypeCastException : ClassCastException
class UninitializedPropertyAccessException : RuntimeException
class UninitializedPropertyAccessException : RuntimeException
open class UninitializedPropertyAccessException : RuntimeException
open class UnsupportedOperationException : RuntimeException
typealias UnsupportedOperationException = UnsupportedOperationException
Returns true
if this lateinit property has been assigned a value, and false
otherwise.
val KProperty0<*>.isInitialized: Boolean
Returns an array of stack trace elements representing the stack trace pertaining to this throwable.
val Throwable.stackTrace: Array<StackTraceElement>
Returns a list of all exceptions that were suppressed in order to deliver this exception.
val Throwable.suppressedExceptions: List<Throwable>
When supported by the platform, adds the specified exception to the list of exceptions that were suppressed in order to deliver this exception.
fun Throwable.addSuppressed(exception: Throwable)
Calls the specified function block with this
value as its argument and returns this
value.
fun <T> T.also(block: (T) -> Unit): T
Calls the specified function block with this
value as its receiver and returns this
value.
fun <T> T.apply(block: T.() -> Unit): T
Returns an array containing the specified elements.
fun <T> arrayOf(vararg elements: T): 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?>
Throws an AssertionError if the value is false and runtime assertions have been enabled on the JVM using the -ea JVM option.
fun assert(value: Boolean)
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.
fun assert(value: Boolean, lazyMessage: () -> Any)
Returns an array containing the specified boolean values.
fun booleanArrayOf(vararg elements: Boolean): BooleanArray
Returns an array containing the specified Byte numbers.
fun byteArrayOf(vararg elements: Byte): ByteArray
Returns an array containing the specified characters.
fun charArrayOf(vararg elements: Char): CharArray
Throws an IllegalStateException if the value is false.
fun check(value: Boolean)
Throws an IllegalStateException with the result of calling lazyMessage if the value is false.
fun check(value: Boolean, lazyMessage: () -> Any)
Throws an IllegalStateException if the value is null. Otherwise returns the not null value.
fun <T : Any> checkNotNull(value: T?): T
Throws an IllegalStateException with the result of calling lazyMessage if the value is null. Otherwise returns the not null value.
fun <T : Any> checkNotNull( value: T?, lazyMessage: () -> Any ): T
Counts the number of consecutive most significant bits that are zero in the binary representation of this UInt number.
fun UInt.countLeadingZeroBits(): Int
Counts the number of consecutive most significant bits that are zero in the binary representation of this ULong number.
fun ULong.countLeadingZeroBits(): Int
Counts the number of consecutive most significant bits that are zero in the binary representation of this UByte number.
fun UByte.countLeadingZeroBits(): Int
Counts the number of consecutive most significant bits that are zero in the binary representation of this UShort number.
fun UShort.countLeadingZeroBits(): Int
Counts the number of consecutive most significant bits that are zero in the binary representation of this Byte number.
fun Byte.countLeadingZeroBits(): Int
Counts the number of consecutive most significant bits that are zero in the binary representation of this Short number.
fun Short.countLeadingZeroBits(): Int
Counts the number of consecutive most significant bits that are zero in the binary representation of this Int number.
fun Int.countLeadingZeroBits(): Int
Counts the number of consecutive most significant bits that are zero in the binary representation of this Long number.
fun Long.countLeadingZeroBits(): Int
Counts the number of set bits in the binary representation of this UInt number.
fun UInt.countOneBits(): Int
Counts the number of set bits in the binary representation of this ULong number.
fun ULong.countOneBits(): Int
Counts the number of set bits in the binary representation of this UByte number.
fun UByte.countOneBits(): Int
Counts the number of set bits in the binary representation of this UShort number.
fun UShort.countOneBits(): Int
Counts the number of set bits in the binary representation of this Byte number.
fun Byte.countOneBits(): Int
Counts the number of set bits in the binary representation of this Short number.
fun Short.countOneBits(): Int
Counts the number of set bits in the binary representation of this Int number.
fun Int.countOneBits(): Int
Counts the number of set bits in the binary representation of this Long number.
fun Long.countOneBits(): Int
Counts the number of consecutive least significant bits that are zero in the binary representation of this UInt number.
fun UInt.countTrailingZeroBits(): Int
Counts the number of consecutive least significant bits that are zero in the binary representation of this ULong number.
fun ULong.countTrailingZeroBits(): Int
Counts the number of consecutive least significant bits that are zero in the binary representation of this UByte number.
fun UByte.countTrailingZeroBits(): Int
Counts the number of consecutive least significant bits that are zero in the binary representation of this UShort number.
fun UShort.countTrailingZeroBits(): Int
Counts the number of consecutive least significant bits that are zero in the binary representation of this Byte number.
fun Byte.countTrailingZeroBits(): Int
Counts the number of consecutive least significant bits that are zero in the binary representation of this Short number.
fun Short.countTrailingZeroBits(): Int
Counts the number of consecutive least significant bits that are zero in the binary representation of this Int number.
fun Int.countTrailingZeroBits(): Int
Counts the number of consecutive least significant bits that are zero in the binary representation of this Long number.
fun Long.countTrailingZeroBits(): Int
Returns an array containing the specified Double numbers.
fun doubleArrayOf(vararg elements: Double): DoubleArray
Returns an empty array of the specified type T.
fun <T> emptyArray(): Array<T>
Returns an enum entry with specified name.
fun <T : Enum<T>> enumValueOf(name: String): T
Returns an array containing enum T entries.
fun <T : Enum<T>> enumValues(): Array<T>
Throws an IllegalStateException with the given message.
fun error(message: Any): Nothing
Returns an array containing the specified Float numbers.
fun floatArrayOf(vararg elements: Float): FloatArray
Returns the encapsulated value if this instance represents success or the defaultValue if it is failure.
fun <R, T : R> Result<T>.getOrDefault(defaultValue: R): R
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.
operator fun <V> KProperty0<V>.getValue( thisRef: Any?, property: KProperty<*> ): V
Returns a hash code value for the object or zero if the object is null
.
fun Any?.hashCode(): Int
Returns an array containing the specified Int numbers.
fun intArrayOf(vararg elements: Int): IntArray
Initiates a call to this deep recursive function, forming a root of the call tree.
operator fun <T, R> DeepRecursiveFunction<T, R>.invoke( value: T ): R
Returns true
if the argument is a finite floating-point value; returns false
otherwise (for NaN
and infinity arguments).
fun Double.isFinite(): Boolean
fun Float.isFinite(): Boolean
Returns true
if this value is infinitely large in magnitude.
fun Double.isInfinite(): Boolean
fun Float.isInfinite(): Boolean
Returns true
if the specified number is a Not-a-Number (NaN) value, false
otherwise.
fun Double.isNaN(): Boolean
fun Float.isNaN(): Boolean
Creates a new instance of the Lazy that uses the specified initialization function initializer and the default thread-safety mode LazyThreadSafetyMode.SYNCHRONIZED.
fun <T> lazy(initializer: () -> T): Lazy<T>
Creates a new instance of the Lazy that uses the specified initialization function initializer.
fun <T> lazy( mode: LazyThreadSafetyMode, initializer: () -> T ): Lazy<T>
fun <T> lazy(lock: Any?, initializer: () -> T): Lazy<T>
Calls the specified function block with this
value as its argument and returns its result.
fun <T, R> T.let(block: (T) -> R): R
Returns an array containing the specified Long numbers.
fun longArrayOf(vararg elements: Long): LongArray
Prints the detailed description of this throwable to the specified writer.
fun Throwable.printStackTrace(writer: PrintWriter)
Prints the detailed description of this throwable to the specified stream.
fun Throwable.printStackTrace(stream: PrintStream)
Prints the detailed description of this throwable to the standard output or standard error output.
fun Throwable.printStackTrace()
Throws an IllegalArgumentException if the value is false.
fun require(value: Boolean)
Throws an IllegalArgumentException with the result of calling lazyMessage if the value is false.
fun require(value: Boolean, lazyMessage: () -> Any)
Throws an IllegalArgumentException if the value is null. Otherwise returns the not null value.
fun <T : Any> requireNotNull(value: T?): T
Throws an IllegalArgumentException with the result of calling lazyMessage if the value is null. Otherwise returns the not null value.
fun <T : Any> requireNotNull( value: T?, lazyMessage: () -> Any ): T
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.
fun UInt.rotateLeft(bitCount: Int): UInt
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.
fun ULong.rotateLeft(bitCount: Int): ULong
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.
fun UByte.rotateLeft(bitCount: Int): UByte
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.
fun UShort.rotateLeft(bitCount: Int): UShort
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.
fun Byte.rotateLeft(bitCount: Int): Byte
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.
fun Short.rotateLeft(bitCount: Int): Short
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.
fun UInt.rotateRight(bitCount: Int): UInt
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.
fun ULong.rotateRight(bitCount: Int): ULong
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.
fun UByte.rotateRight(bitCount: Int): UByte
Rotates the binary representation of this UShort 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.
fun UShort.rotateRight(bitCount: Int): UShort
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.
fun Byte.rotateRight(bitCount: Int): Byte
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.
fun Short.rotateRight(bitCount: Int): Short
Calls the specified function block and returns its result.
fun <R> run(block: () -> R): R
Calls the specified function block with this
value as its receiver and returns its result.
fun <T, R> T.run(block: T.() -> R): R
Calls the specified function block and returns its encapsulated result if invocation was successful, catching any Throwable exception that was thrown from the block function execution and encapsulating it as a failure.
fun <R> runCatching(block: () -> R): Result<R>
Calls the specified function block with this
value as its receiver and returns its encapsulated result if invocation was successful, catching any Throwable exception that was thrown from the block function execution and encapsulating it as a failure.
fun <T, R> T.runCatching(block: T.() -> R): Result<R>
Returns an array containing the specified Short numbers.
fun shortArrayOf(vararg elements: Short): ShortArray
Returns the detailed description of this throwable with its stack trace.
fun Throwable.stackTraceToString(): String
fun <R> suspend(block: suspend () -> R): suspend () -> R
Returns a number having a single bit set in the position of the most significant set bit of this UInt number, or zero, if this number is zero.
fun UInt.takeHighestOneBit(): UInt
Returns a number having a single bit set in the position of the most significant set bit of this ULong number, or zero, if this number is zero.
fun ULong.takeHighestOneBit(): ULong
Returns a number having a single bit set in the position of the most significant set bit of this UByte number, or zero, if this number is zero.
fun UByte.takeHighestOneBit(): UByte
Returns a number having a single bit set in the position of the most significant set bit of this UShort number, or zero, if this number is zero.
fun UShort.takeHighestOneBit(): UShort
Returns a number having a single bit set in the position of the most significant set bit of this Byte number, or zero, if this number is zero.
fun Byte.takeHighestOneBit(): Byte
Returns a number having a single bit set in the position of the most significant set bit of this Short number, or zero, if this number is zero.
fun Short.takeHighestOneBit(): Short
Returns a number having a single bit set in the position of the most significant set bit of this Int number, or zero, if this number is zero.
fun Int.takeHighestOneBit(): Int
Returns a number having a single bit set in the position of the most significant set bit of this Long number, or zero, if this number is zero.
fun Long.takeHighestOneBit(): Long
Returns this
value if it satisfies the given predicate or null
, if it doesn't.
fun <T> T.takeIf(predicate: (T) -> Boolean): T?
Returns a number having a single bit set in the position of the least significant set bit of this UInt number, or zero, if this number is zero.
fun UInt.takeLowestOneBit(): UInt
Returns a number having a single bit set in the position of the least significant set bit of this ULong number, or zero, if this number is zero.
fun ULong.takeLowestOneBit(): ULong
Returns a number having a single bit set in the position of the least significant set bit of this UByte number, or zero, if this number is zero.
fun UByte.takeLowestOneBit(): UByte
Returns a number having a single bit set in the position of the least significant set bit of this UShort number, or zero, if this number is zero.
fun UShort.takeLowestOneBit(): UShort
Returns a number having a single bit set in the position of the least significant set bit of this Byte number, or zero, if this number is zero.
fun Byte.takeLowestOneBit(): Byte
Returns a number having a single bit set in the position of the least significant set bit of this Short number, or zero, if this number is zero.
fun Short.takeLowestOneBit(): Short
Returns a number having a single bit set in the position of the least significant set bit of this Int number, or zero, if this number is zero.
fun Int.takeLowestOneBit(): Int
Returns a number having a single bit set in the position of the least significant set bit of this Long number, or zero, if this number is zero.
fun Long.takeLowestOneBit(): Long
Returns this
value if it does not satisfy the given predicate or null
, if it does.
fun <T> T.takeUnless(predicate: (T) -> Boolean): T?
Returns the value of this Int number as a BigDecimal.
fun Int.toBigDecimal(): BigDecimal
fun Int.toBigDecimal(mathContext: MathContext): BigDecimal
Returns the value of this Long number as a BigDecimal.
fun Long.toBigDecimal(): BigDecimal
fun Long.toBigDecimal(mathContext: MathContext): BigDecimal
Returns the value of this Float number as a BigDecimal.
fun Float.toBigDecimal(): BigDecimal
fun Float.toBigDecimal(mathContext: MathContext): BigDecimal
Returns the value of this Double number as a BigDecimal.
fun Double.toBigDecimal(): BigDecimal
fun Double.toBigDecimal(mathContext: MathContext): BigDecimal
Returns the value of this Int number as a BigInteger.
fun Int.toBigInteger(): BigInteger
Returns the value of this Long number as a BigInteger.
fun Long.toBigInteger(): BigInteger
Returns a bit representation of the specified floating-point value as Long according to the IEEE 754 floating-point "double format" bit layout.
fun Double.toBits(): Long
Returns a bit representation of the specified floating-point value as Int according to the IEEE 754 floating-point "single format" bit layout.
fun Float.toBits(): Int
Always throws NotImplementedError stating that operation is not implemented.
fun TODO(): Nothing
fun TODO(reason: String): Nothing
Converts this pair into a list.
fun <T> Pair<T, T>.toList(): List<T>
Converts this triple into a list.
fun <T> Triple<T, T, T>.toList(): List<T>
Returns a bit representation of the specified floating-point value as Long according to the IEEE 754 floating-point "double format" bit layout, preserving NaN
values exact layout.
fun Double.toRawBits(): Long
Returns a bit representation of the specified floating-point value as Int according to the IEEE 754 floating-point "single format" bit layout, preserving NaN
values exact layout.
fun Float.toRawBits(): Int
Returns a string representation of the object. Can be called with a null receiver, in which case it returns the string "null".
fun Any?.toString(): String
fun ubyteArrayOf(vararg elements: UByte): UByteArray
fun uintArrayOf(vararg elements: UInt): UIntArray
fun ulongArrayOf(vararg elements: ULong): ULongArray
Executes the given block function on this resource and then closes it down correctly whether an exception is thrown or not.
fun <T : AutoCloseable?, R> T.use(block: (T) -> R): R
fun ushortArrayOf(vararg elements: UShort): UShortArray
Returns the Double value corresponding to a given bit representation.
fun Double.Companion.fromBits(bits: Long): Double
Returns the Float value corresponding to a given bit representation.
fun Float.Companion.fromBits(bits: Int): Float
© 2010–2020 JetBrains s.r.o. and Kotlin Programming Language contributors
Licensed under the Apache License, Version 2.0.
https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/index.html