Package kotlin
Core functions and types, available on all supported platforms.
Types
Annotation
Base interface implicitly implemented by all annotation interfaces. See Kotlin language documentation for more information on annotations.
interface
Annotation
Any
The root of the Kotlin class hierarchy. Every Kotlin class has Any as a superclass.
open
class
Any
Array
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
>
ArrayIndexOutOfBoundsException
open
class
ArrayIndexOutOfBoundsException
:
IndexOutOfBoundsException
AutoCloseable
A resource that can be closed or released.
interface
AutoCloseable
Boolean
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
>
BooleanArray
An array of booleans. When targeting the JVM, instances of this class are represented as
boolean[]
.
class
BooleanArray
Byte
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
>
ByteArray
An array of bytes. When targeting the JVM, instances of this class are represented as
byte[]
.
class
ByteArray
Char
Represents a 16-bit Unicode character.
class
Char
:
Comparable
<
Char
>
CharArray
An array of chars. When targeting the JVM, instances of this class are represented as
char[]
.
class
CharArray
CharSequence
Represents a readable sequence of Char values.
interface
CharSequence
Comparable
Classes which inherit from this interface have a defined total ordering between their instances.
interface
Comparable
<
in
T
>
Comparator
Provides a comparison function for imposing a total ordering between instances of the type T .
fun
interface
Comparator
<
T
>
typealias
Comparator
<
T
>
=
Comparator
<
T
>
DeepRecursiveFunction
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
>
DeepRecursiveScope
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
>
DeprecationLevel
Possible levels of a deprecation. The level specifies how the deprecated element usages are reported in code.
enum
class
DeprecationLevel
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
>
DoubleArray
An array of doubles. When targeting the JVM, instances of this class are represented as
double[]
.
class
DoubleArray
Enum
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
>
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
>
FloatArray
An array of floats. When targeting the JVM, instances of this class are represented as
float[]
.
class
FloatArray
Function
Represents a value of a functional type, such as a lambda, an anonymous function or a function reference.
interface
Function
<
out
R
>
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
>
IntArray
An array of ints. When targeting the JVM, instances of this class are represented as
int[]
.
class
IntArray
KotlinVersion
Represents a version of the Kotlin standard library.
class
KotlinVersion
:
Comparable
<
KotlinVersion
>
Lazy
Represents a value with lazy initialization.
interface
Lazy
<
out
T
>
LazyThreadSafetyMode
Specifies how a Lazy instance synchronizes initialization among multiple threads.
enum
class
LazyThreadSafetyMode
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
>
LongArray
An array of longs. When targeting the JVM, instances of this class are represented as
long[]
.
class
LongArray
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
Number
Superclass for all platform classes representing numeric values.
abstract
class
Number
OutOfMemoryError
open
class
OutOfMemoryError
:
Error
Pair
Represents a generic pair of two values.
data
class
Pair
<
out
A
,
out
B
>
:
Serializable
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
>
ShortArray
An array of shorts. When targeting the JVM, instances of this class are represented as
short[]
.
class
ShortArray
String
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
Throwable
The base class for all errors and exceptions. Only instances of this class can be thrown or caught.
open
class
Throwable
Triple
Represents a triad of values
data
class
Triple
<
out
A
,
out
B
,
out
C
>
:
Serializable
UByte
class
UByte
:
Comparable
<
UByte
>
UByteArray
class
UByteArray
:
Collection
<
UByte
>
UInt
class
UInt
:
Comparable
<
UInt
>
UIntArray
class
UIntArray
:
Collection
<
UInt
>
ULong
class
ULong
:
Comparable
<
ULong
>
ULongArray
class
ULongArray
:
Collection
<
ULong
>
Unit
The type with only one value: the
Unit
object. This type corresponds to the
void
type in Java.
object
Unit
UShort
class
UShort
:
Comparable
<
UShort
>
UShortArray
class
UShortArray
:
Collection
<
UShort
>
Annotations
BuilderInference
Allows to infer generic type arguments of a function from the calls in the annotated function parameter of that function.
annotation
class
BuilderInference
ContextFunctionTypeParams
Signifies that the annotated functional type has the prefix of size
count
for context receivers.
Thus,
@ContextFunctionTypeParams(2) @ExtensionFunctionType Function4<String, Int, Double, Byte, Unit>
is a normalized representation of
context(String, Int) Double.(Byte) -> Unit
.
annotation
class
ContextFunctionTypeParams
Deprecated
Marks the annotated declaration as deprecated.
annotation
class
Deprecated
DeprecatedSinceKotlin
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
DslMarker
When applied to annotation class X specifies that X defines a DSL language
annotation
class
DslMarker
ExperimentalMultiplatform
The experimental multiplatform support API marker.
annotation
class
ExperimentalMultiplatform
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.
annotation
class
ExperimentalStdlibApi
ExperimentalSubclassOptIn
This annotation marks the experimental preview of the language feature SubclassOptInRequired .
annotation
class
ExperimentalSubclassOptIn
ExperimentalUnsignedTypes
Marks the API that is dependent on the experimental unsigned types, including those types themselves.
annotation
class
ExperimentalUnsignedTypes
ExtensionFunctionType
Signifies that the annotated functional type represents an extension function.
annotation
class
ExtensionFunctionType
Metadata
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
OptIn
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
OptionalExpectation
Marks an expected annotation class that it isn't required to have actual counterparts in all platforms.
annotation
class
OptionalExpectation
OverloadResolutionByLambdaReturnType
Enables overload selection based on the type of the value returned from lambda argument.
annotation
class
OverloadResolutionByLambdaReturnType
ParameterName
Annotates type arguments of functional type and holds corresponding parameter name specified by the user in type declaration (if any).
annotation
class
ParameterName
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.
annotation
class
PublishedApi
ReplaceWith
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
RequiresOptIn
Signals that the annotated annotation class is a marker of an API that requires an explicit opt-in.
annotation
class
RequiresOptIn
SinceKotlin
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
SubclassOptInRequired
Annotation that marks open for subclassing classes and interfaces, and makes implementation and extension of such declarations as requiring an explicit opt-in.
annotation
class
SubclassOptInRequired
Suppress
Suppresses the given compilation warnings in the annotated element.
annotation
class
Suppress
Throws
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
UnsafeVariance
Suppresses errors about variance conflict
annotation
class
UnsafeVariance
Exceptions
ArithmeticException
open
class
ArithmeticException
:
RuntimeException
typealias
ArithmeticException
=
ArithmeticException
AssertionError
open
class
AssertionError
:
Error
typealias
AssertionError
=
AssertionError
ClassCastException
open
class
ClassCastException
:
RuntimeException
typealias
ClassCastException
=
ClassCastException
ConcurrentModificationException
open
class
ConcurrentModificationException
:
RuntimeException
typealias
ConcurrentModificationException
=
ConcurrentModificationException
IllegalArgumentException
open
class
IllegalArgumentException
:
RuntimeException
typealias
IllegalArgumentException
=
IllegalArgumentException
IllegalStateException
open
class
IllegalStateException
:
RuntimeException
typealias
IllegalStateException
=
IllegalStateException
IndexOutOfBoundsException
open
class
IndexOutOfBoundsException
:
RuntimeException
typealias
IndexOutOfBoundsException
=
IndexOutOfBoundsException
KotlinNullPointerException
open
class
KotlinNullPointerException
:
NullPointerException
NoSuchElementException
open
class
NoSuchElementException
:
RuntimeException
typealias
NoSuchElementException
=
NoSuchElementException
NotImplementedError
An exception is thrown to indicate that a method body remains to be implemented.
class
NotImplementedError
:
Error
NoWhenBranchMatchedException
open
class
NoWhenBranchMatchedException
:
RuntimeException
open
class
NoWhenBranchMatchedException
:
RuntimeException
NullPointerException
open
class
NullPointerException
:
RuntimeException
typealias
NullPointerException
=
NullPointerException
NumberFormatException
open
class
NumberFormatException
:
IllegalArgumentException
typealias
NumberFormatException
=
NumberFormatException
RuntimeException
open
class
RuntimeException
:
Exception
typealias
RuntimeException
=
RuntimeException
TypeCastException
open
class
TypeCastException
:
ClassCastException
UninitializedPropertyAccessException
class
UninitializedPropertyAccessException
:
RuntimeException
class
UninitializedPropertyAccessException
:
RuntimeException
open
class
UninitializedPropertyAccessException
:
RuntimeException
UnsupportedOperationException
open
class
UnsupportedOperationException
:
RuntimeException
typealias
UnsupportedOperationException
=
UnsupportedOperationException
Extensions for External Classes
Properties
code
Returns the code of this Char.
val
Char
.
code
:
Int
isInitialized
Returns
true
if this lateinit property has been assigned a value, and
false
otherwise.
val
KProperty0
<
*
>
.
isInitialized
:
Boolean
stackTrace
Returns an array of stack trace elements representing the stack trace pertaining to this throwable.
val
Throwable
.
stackTrace
:
Array
<
StackTraceElement
>
Functions
also
Calls the specified function
block
with
this
value as its argument and returns
this
value.
fun
<
T
>
T
.
also
(
block
:
(
T
)
->
Unit
)
:
T
apply
Calls the specified function
block
with
this
value as its receiver and returns
this
value.
fun
<
T
>
T
.
apply
(
block
:
T
.
(
)
->
Unit
)
:
T
arrayOf
Returns an array containing the specified elements.
fun
<
T
>
arrayOf
(
vararg
elements
:
T
)
:
Array
<
T
>
arrayOfNulls
Returns an array of objects of the given type with the given size , initialized with null values.
fun
<
T
>
arrayOfNulls
(
size
:
Int
)
:
Array
<
T
?
>
assert
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
)
booleanArrayOf
Returns an array containing the specified boolean values.
fun
booleanArrayOf
(
vararg
elements
:
Boolean
)
:
BooleanArray
Char
charArrayOf
Returns an array containing the specified characters.
fun
charArrayOf
(
vararg
elements
:
Char
)
:
CharArray
check
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
)
checkNotNull
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
compareTo
Compares this object with the specified object for order. Returns zero if this object is equal to the specified other object, a negative number if it's less than other , or a positive number if it's greater than other .
infix
fun
<
T
>
Comparable
<
T
>
.
compareTo
(
other
:
T
)
:
Int
countLeadingZeroBits
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 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 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
countOneBits
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 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 Int number.
fun
Int
.
countOneBits
(
)
:
Int
Counts the number of set bits in the binary representation of this Long number.
fun
Long
.
countOneBits
(
)
:
Int
countTrailingZeroBits
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 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 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
doubleArrayOf
Returns an array containing the specified Double numbers.
fun
doubleArrayOf
(
vararg
elements
:
Double
)
:
DoubleArray
emptyArray
Returns an empty array of the specified type T .
fun
<
T
>
emptyArray
(
)
:
Array
<
T
>
enumValueOf
Returns an enum entry with specified name.
fun
<
T
:
Enum
<
T
>
>
enumValueOf
(
name
:
String
)
:
T
enumValues
Returns an array containing enum T entries.
fun
<
T
:
Enum
<
T
>
>
enumValues
(
)
:
Array
<
T
>
error
Throws an IllegalStateException with the given message .
fun
error
(
message
:
Any
)
:
Nothing
floatArrayOf
Returns an array containing the specified Float numbers.
fun
floatArrayOf
(
vararg
elements
:
Float
)
:
FloatArray
floorDiv
Divides this value by the other value, flooring the result to an integer that is closer to negative infinity.
fun
Byte
.
floorDiv
(
other
:
Byte
)
:
Int
fun
Byte
.
floorDiv
(
other
:
Short
)
:
Int
fun
Byte
.
floorDiv
(
other
:
Int
)
:
Int
fun
Byte
.
floorDiv
(
other
:
Long
)
:
Long
fun
Short
.
floorDiv
(
other
:
Byte
)
:
Int
fun
Short
.
floorDiv
(
other
:
Short
)
:
Int
fun
Short
.
floorDiv
(
other
:
Int
)
:
Int
fun
Short
.
floorDiv
(
other
:
Long
)
:
Long
fun
Int
.
floorDiv
(
other
:
Byte
)
:
Int
fun
Int
.
floorDiv
(
other
:
Short
)
:
Int
fun
Int
.
floorDiv
(
other
:
Int
)
:
Int
fun
Int
.
floorDiv
(
other
:
Long
)
:
Long
fun
Long
.
floorDiv
(
other
:
Byte
)
:
Long
fun
Long
.
floorDiv
(
other
:
Short
)
:
Long
fun
Long
.
floorDiv
(
other
:
Int
)
:
Long
fun
Long
.
floorDiv
(
other
:
Long
)
:
Long
fold
getOrDefault
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
getValue
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
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.
operator
fun
<
T
,
V
>
KProperty1
<
T
,
V
>
.
getValue
(
thisRef
:
T
,
property
:
KProperty
<
*
>
)
:
V
hashCode
Returns a hash code value for the object or zero if the object is
null
.
fun
Any
?
.
hashCode
(
)
:
Int
invoke
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
isFinite
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
isInfinite
Returns
true
if this value is infinitely large in magnitude.
fun
Double
.
isInfinite
(
)
:
Boolean
fun
Float
.
isInfinite
(
)
:
Boolean
isNaN
Returns
true
if the specified number is a
Not-a-Number (NaN) value,
false
otherwise.
fun
Double
.
isNaN
(
)
:
Boolean
fun
Float
.
isNaN
(
)
:
Boolean
lazy
Creates a new instance of the Lazy that uses the specified initialization function initializer .
fun
<
T
>
lazy
(
mode
:
<ERROR CLASS>
,
initializer
:
(
)
->
T
)
:
<ERROR CLASS>
<
T
>
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
>
fun
<
T
>
lazy
(
initializer
:
(
)
->
T
)
:
<ERROR CLASS>
<
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
>
fun
<
T
>
lazy
(
lock
:
Any
?
,
initializer
:
(
)
->
T
)
:
Lazy
<
T
>
fun
<
T
>
lazy
(
lock
:
Any
?
,
initializer
:
(
)
->
T
)
:
<ERROR CLASS>
<
T
>
let
Calls the specified function
block
with
this
value as its argument and returns its result.
fun
<
T
,
R
>
T
.
let
(
block
:
(
T
)
->
R
)
:
R
mod
Calculates the remainder of flooring division of this value (dividend) by the other value (divisor).
fun
Byte
.
mod
(
other
:
Byte
)
:
Byte
fun
Byte
.
mod
(
other
:
Short
)
:
Short
fun
Byte
.
mod
(
other
:
Int
)
:
Int
fun
Byte
.
mod
(
other
:
Long
)
:
Long
fun
Short
.
mod
(
other
:
Byte
)
:
Byte
fun
Short
.
mod
(
other
:
Short
)
:
Short
fun
Short
.
mod
(
other
:
Int
)
:
Int
fun
Short
.
mod
(
other
:
Long
)
:
Long
fun
Int
.
mod
(
other
:
Byte
)
:
Byte
fun
Int
.
mod
(
other
:
Short
)
:
Short
fun
Int
.
mod
(
other
:
Int
)
:
Int
fun
Int
.
mod
(
other
:
Long
)
:
Long
fun
Long
.
mod
(
other
:
Byte
)
:
Byte
fun
Long
.
mod
(
other
:
Short
)
:
Short
fun
Long
.
mod
(
other
:
Int
)
:
Int
fun
Long
.
mod
(
other
:
Long
)
:
Long
fun
Float
.
mod
(
other
:
Float
)
:
Float
fun
Float
.
mod
(
other
:
Double
)
:
Double
fun
Double
.
mod
(
other
:
Float
)
:
Double
fun
Double
.
mod
(
other
:
Double
)
:
Double
printStackTrace
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
(
)
recover
recoverCatching
require
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
)
requireNotNull
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
rotateLeft
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 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.
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.
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.
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.
rotateRight
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
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.
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.
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.
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.
run
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
runCatching
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
>
setValue
An extension operator that allows delegating a mutable property of type V to a property reference to a mutable property of the same type V .
operator
fun
<
V
>
KMutableProperty0
<
V
>
.
setValue
(
thisRef
:
Any
?
,
property
:
KProperty
<
*
>
,
value
:
V
)
An extension operator that allows delegating a mutable member or extension property of type V to a property reference to a member or extension mutable property of the same type V .
operator
fun
<
T
,
V
>
KMutableProperty1
<
T
,
V
>
.
setValue
(
thisRef
:
T
,
property
:
KProperty
<
*
>
,
value
:
V
)
shortArrayOf
Returns an array containing the specified Short numbers.
fun
shortArrayOf
(
vararg
elements
:
Short
)
:
ShortArray
stackTraceToString
Returns the detailed description of this throwable with its stack trace.
fun
Throwable
.
stackTraceToString
(
)
:
String
suspend
fun
<
R
>
suspend
(
block
:
suspend
(
)
->
R
)
:
suspend
(
)
->
R
takeHighestOneBit
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 UInt number, or zero, if this number is zero.
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.
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.
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.
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
takeIf
Returns
this
value if it satisfies the given
predicate
or
null
, if it doesn't.
fun
<
T
>
T
.
takeIf
(
predicate
:
(
T
)
->
Boolean
)
:
T
?
takeLowestOneBit
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 UInt number, or zero, if this number is zero.
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.
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.
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.
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
takeUnless
Returns
this
value if it
does not
satisfy the given
predicate
or
null
, if it does.
fun
<
T
>
T
.
takeUnless
(
predicate
:
(
T
)
->
Boolean
)
:
T
?
toBigDecimal
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
toBigInteger
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
toBits
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
TODO
Always throws NotImplementedError stating that operation is not implemented.
fun
TODO
(
)
:
Nothing
fun
TODO
(
reason
:
String
)
:
Nothing
toRawBits
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
toString
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
UByteArray
Creates a new array of the specified size , where each element is calculated by calling the specified init function.
fun
UByteArray
(
size
:
Int
,
init
:
(
Int
)
->
UByte
)
:
UByteArray
ubyteArrayOf
fun
ubyteArrayOf
(
vararg
elements
:
UByte
)
:
UByteArray
ULongArray
Creates a new array of the specified size , where each element is calculated by calling the specified init function.
fun
ULongArray
(
size
:
Int
,
init
:
(
Int
)
->
ULong
)
:
ULongArray
ulongArrayOf
fun
ulongArrayOf
(
vararg
elements
:
ULong
)
:
ULongArray
use
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
<
T
:
AutoCloseable
?
,
R
>
T
.
use
(
block
:
(
T
)
->
R
)
:
R
UShortArray
Creates a new array of the specified size , where each element is calculated by calling the specified init function.
fun
UShortArray
(
size
:
Int
,
init
:
(
Int
)
->
UShort
)
:
UShortArray
ushortArrayOf
fun
ushortArrayOf
(
vararg
elements
:
UShort
)
:
UShortArray