kotlin-stdlib

Provides a skeletal implementation of the read-only Collection interface.

Base class for CoroutineContext.Element implementations.

Base class for CoroutineContext.Key associated with polymorphic CoroutineContext.Element implementation. Polymorphic element implementation implies delegating its get and minusKey to getPolymorphicElement and minusPolymorphicKey respectively.

An abstract class used to implement time sources that return their readings as Double values in the specified unit.

A base class to simplify implementing iterators so that implementations only have to implement computeNext to implement the iterator, calling done when the iteration is complete.

Provides a skeletal implementation of the read-only List interface.

An abstract class used to implement time sources that return their readings as Long values in the specified unit.

Provides a skeletal implementation of the read-only Map interface.

Provides a skeletal implementation of the MutableCollection interface.

Provides a skeletal implementation of the MutableList interface.

Provides a skeletal implementation of the MutableMap interface.

Provides a skeletal implementation of the MutableSet interface.

Provides a skeletal implementation of the read-only Set interface.

An exception class which is used when we have not enough access for some operation.

Base interface implicitly implemented by all annotation interfaces. See Kotlin language documentation for more information on annotations.

Contains the list of possible annotation's retentions.

Contains the list of code elements which are the possible annotation targets

The root of the Kotlin class hierarchy. Every Kotlin class has Any as a superclass.

An object to which char sequences and values can be appended.

A generic array of objects. When targeting the JVM, instances of this class are represented as T[]. Array instances can be created using the arrayOf, arrayOfNulls and emptyArray standard library functions.

Resizable-array implementation of the deque data structure.

Provides a MutableList implementation, which uses a resizable array as its backing storage.

Makes the annotated annotation class an associated object key.

Makes the annotated annotation class an associated object key.

Makes the annotated annotation class an associated object key.

Makes the annotated annotation class an associated object key.

An Array in which elements are always updated atomically. For additional details about atomicity guarantees for reads and writes see kotlin.concurrent.Volatile.

A generic array of objects in which elements may be updated atomically.

A Boolean value that may be updated atomically.

An Int value that is always updated atomically. For additional details about atomicity guarantees for reads and writes see kotlin.concurrent.Volatile.

An Int value that is always updated atomically. For additional details about atomicity guarantees for reads and writes see kotlin.concurrent.Volatile.

An Int value that may be updated atomically.

An IntArray in which elements are always updated atomically. For additional details about atomicity guarantees for reads and writes see kotlin.concurrent.Volatile.

An array of ints in which elements may be updated atomically.

A Long value that is always updated atomically. For additional details about atomicity guarantees for reads and writes see kotlin.concurrent.Volatile.

A Long value that is always updated atomically. For additional details about atomicity guarantees for reads and writes see kotlin.concurrent.Volatile.

A Long value that may be updated atomically.

An LongArray in which elements are always updated atomically. For additional details about atomicity guarantees for reads and writes see kotlin.concurrent.Volatile.

An array of longs in which elements may be updated atomically.

A kotlinx.cinterop.NativePtr value that is always updated atomically. For additional details about atomicity guarantees for reads and writes see kotlin.concurrent.Volatile.

A kotlinx.cinterop.NativePtr value that is always updated atomically. For additional details about atomicity guarantees for reads and writes see kotlin.concurrent.Volatile.

A kotlinx.cinterop.NativePtr that may be updated atomically.

An object reference that is always updated atomically.

An object reference that is always updated atomically.

An object reference that may be updated atomically.

A resource that can be closed or released.

Provides Base64 encoding and decoding functionality. Base64 encoding, as defined by the RFC 4648 and a few other RFCs, transforms arbitrary binary data into a sequence of printable characters.

Marks Objective-C and Swift interoperability API as Beta.

A vector of bits growing if necessary and allowing one to set/clear/read bits from it by a bit index.

Represents a value which is either true or false.

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

An iterator over a sequence of values of type Boolean.

Allows to infer generic type arguments of a function from the calls in the annotated function parameter of that function.

Represents a 8-bit signed integer.

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

An iterator over a sequence of values of type Byte.

An effect of calling a functional parameter in place.

Thrown by cancellable suspending functions if the coroutine is cancelled while it is suspended. It indicates normal cancellation of a coroutine.

Denotes property that is an alias to some enum entry.

Stores instance size of the type T: CEnumVar.

The C function.

Represents a 16-bit Unicode character.

The exception thrown when a character encoding or decoding error occurs.

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

Represents the character general category in the Unicode specification.

Represents the Unicode directionality of a character. Character directionality is used to calculate the visual ordering of text.

An iterator over a sequence of values of type Char.

A progression of values of type Char.

A range of values of type Char.

Represents a readable sequence of Char values.

Constant definitions for the standard charsets. These charsets are guaranteed to be available on every implementation of the Java platform.

The marker interface for objects that have a cleanup action associated with them.

A source of Instant values.

Represents a range of floating point numbers. Extends ClosedRange interface providing custom operation lessThanOrEquals for comparing values of range domain type.

Represents a range of values (for example, numbers or characters) where both the lower and upper bounds are included in the range. See the Kotlin language documentation for more information.

Makes top level function available from C/C++ code with the given name.

A generic collection of elements. Methods in this interface support only read-only access to the collection; read/write access is supported through the MutableCollection interface.

Classes which inherit from this interface have a defined total ordering between their instances.

A TimeMark that can be compared for difference with other time marks obtained from the same TimeSource.WithComparableMarks time source.

Provides a comparison function for imposing a total ordering between instances of the type T.

An effect of some condition being true after observing another effect of a function.

In previous versions of Kotlin, the generated 'copy' method of a data class always had public visibility, even if the primary constructor was non-public. That exposed the non-public constructor of the data class.

Exposes the console API to Kotlin.

Collection of annotations that allow to store constant values.

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.

Interface representing a continuation after a suspension point that returns a value of type T.

Marks coroutine context element that intercepts coroutine continuations. The coroutines framework uses ContinuationInterceptor.Key to retrieve the interceptor and intercepts all coroutine continuations with interceptContinuation invocations.

Provides a scope, where the functions of the contract DSL, such as returns, callsInPlace, etc., can be used to describe the contract of a function.

The CPointed without any specified interpretation.

The pointer with an opaque type.

The variable containing a COpaquePointer.

Context for the copyAction function passed to Path.copyToRecursively.

The result of the copyAction function passed to Path.copyToRecursively that specifies further actions when copying an entry.

Persistent context for the coroutine. It is an indexed set of Element instances. An indexed set is a mix between a set and a map. Every element in this set has a unique Key.

C data or code.

C pointer.

The C data variable containing the pointer to T.

The C primitive-typed variable located in memory.

Central Processor Unit architecture.

The C struct-typed variable located in memory.

The single immutable C value. It is self-contained and doesn't depend on native memory.

The (possibly empty) sequence of immutable C values. It is self-contained and doesn't depend on native memory.

Represents a reference to (possibly empty) sequence of C values. It can be either a stable pointer CPointer or a sequence of immutable values CValues.

The C data variable located in memory.

Exposes the Date API to Kotlin.

Note: this API is unstable and may change in any release.

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.

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.

Standard property delegates.

Marks the annotated declaration as 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.

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

Detached object graph encapsulates transferrable detached subgraph which cannot be accessed externally, until it is attached with the attach extension function.

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

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

An iterator over a sequence of values of type Double.

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

Represents the amount of time one instant of time is away from another instant.

The list of possible time measurement units, in which a duration can be expressed.

Represents universal type for JS interoperability.

Forces a top-level property to be initialized eagerly, opposed to lazily on the first access to file and/or property.

Forces a top-level property to be initialized eagerly, opposed to lazily on the first access to file and/or property.

Forces a top-level property to be initialized eagerly, opposed to lazily on the first access to file and/or property.

Forces a top-level property to be initialized eagerly, opposed to lazily on the first access to file and/or property. This annotation can be used as temporal migration assistance during the transition from the previous Kotlin/Native initialization scheme "eager by default" to the new one, "lazy by default".

Represents an effect of a function invocation, either directly observable, such as the function returning normally, or a side-effect, such as the function's lambda parameter being called in place.

An empty coroutine context.

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

A specialized immutable implementation of List interface that contains all enum entries of the specified enum type E. EnumEntries contains all enum entries in the order they are declared in the source code, consistently with the corresponding Enum.ordinal values.

The marked expect declaration refines expect declaration from the closest transitive dependsOn source set. The marked declaration is called a refinement. The annotation can be put only on top-level expect declarations.

The experimental marker for associated objects API.

The experimental marker for associated objects API.

The experimental marker for associated objects API.

The experimental marker for associated objects API.

This annotation marks the experimental Kotlin Atomics API.

This marker distinguishes the experimental contract declaration API and is used to opt-in for that feature when declaring contracts of user functions.

This annotation marks the experimental API for encoding and decoding between binary data and printable ASCII character sequences.

Marks foreign-language-related API as experimental.

This annotation marks the experimental JS-collections API that allows to manipulate with native JS-collections The API can be removed completely in any further release.

Marks experimental JS export annotations.

Marks experimental JsFileName annotation.

This annotation marks the experimental Kotlin/JS reflection API that allows to create an instance of provided KClass The API can be removed completely in any further release.

Marks the experimental JsStatic annotation.

The experimental multiplatform support API marker.

This annotation marks the Kotlin/Native-only 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.

This annotation marks the experimental ObjCName annotation.

This annotation marks the experimental Objective-C export refinement annotations.

This annotation marks the extensions and top-level functions for working with java.nio.file.Path considered experimental.

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.

This annotation marks the experimental preview of the language feature SubclassOptInRequired.

This annotation marks the experimental preview of the standard library API for measuring time and working with durations.

The experimental marker for type inference augmenting annotations.

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

This annotation marks the experimental Kotlin Uuid API.

Makes Kotlin subclass of Objective-C class visible for runtime lookup after Kotlin main function gets invoked.

In previous versions of Kotlin, the generated 'copy' method of a data class always had public visibility, even if the primary constructor was non-public. That exposed the non-public constructor of the data class.

Signifies that the annotated functional type represents an extension function.

An exception class which is used when some file to create or copy to already exists.

A base exception class for file system exceptions.

This class is intended to implement different file traversal methods. It allows to iterate through all files inside a given directory.

The builder to provide implementation of the FileVisitor that fileVisitor function builds.

An enumeration to describe possible walk directions. There are two of them: beginning from parents, ending with children, and beginning from children, ending with parents. Both use depth-first search.

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

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

An iterator over a sequence of values of type Float.

This class was useful only with legacy memory manager. Please use AtomicReference instead.

Exception thrown whenever freezing is not possible.

Freezing API has been deprecated since Kotlin 1.7.20, and support for the legacy memory manager was completely removed from the compiler in 1.9.20.

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

Class representing abstract computation, whose result may become available in the future.

State of the future object.

Note: this API is unstable and may change in any release.

This class represents statistics about the single run of the garbage collector. It is supposed to be used for testing and debugging purposes only.

Represents a source of elements with a keyOf function, which can be applied to each element to get its key.

Hash table based implementation of the MutableMap interface.

The implementation of the MutableSet interface, backed by a InternalMap implementation.

Represents hexadecimal format options for formatting and parsing byte arrays and integer numeric values, both signed and unsigned.

Instructs the Kotlin compiler to remove this class, function or property from the public Objective-C API.

Meta-annotation that instructs the Kotlin compiler to remove the annotated class, function or property from the public Objective-C API.

Expresses that calls of the annotated function are ignorable. Ignorable calls would not trigger a warning from Kotlin's return value checker, even if they are not used.

An immutable compile-time array of bytes.

This annotation marks Kotlin expect declarations that are implicitly actualized by Java.

Exception thrown when top level variable is accessed from incorrect execution context.

Data class representing a value from a collection or sequence, along with its index in that collection or sequence.

A moment in time.

Represents a 32-bit signed integer.

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

An iterator over a sequence of values of type Int.

A progression of values of type Int.

A range of values of type Int.

Exception thrown whenever we attempt to mutate frozen objects.

Specifies how many times a function invokes its function parameter in place.

Classes that inherit from this interface can be represented as a sequence of elements that can be iterated over.

An iterator over a collection or another entity that can be represented as a sequence of elements. Allows to sequentially access the elements.

Any JavaScript value except null or undefined

JavaScript Array

Exposes the JavaScript Array to Kotlin.

JavaScript primitive bigint

JavaScript primitive boolean

Represents the constructor of a class. Instances of JsClass can be passed to JavaScript APIs that expect a constructor reference.

A wrapper for an exception thrown by a JavaScript code. All exceptions thrown by JS code are signalled to Wasm code as JsException.

Exports top-level declaration on JS platform.

When placed on a function parameter, requires the type of the passed argument to be external.

When placed on an external interface or class, requires all its child interfaces, classes, and objects to be external as well.

Specifies the name of the compiled file produced from the annotated source file instead of the default one.

Implements annotated function in JavaScript and automatically imports is to Wasm. code string must contain JS expression that evaluates to JS function with signature that matches annotated kotlin function

Exposes the JavaScript Map to Kotlin.

Denotes an external declaration that must be imported from native JavaScript library.

Denotes an external declaration that must be imported from JavaScript module.

Gives a declaration (a function, a property or a class) specific name in JavaScript.

Denotes an external declaration that can be used without module system.

JavaScript primitive number

An interface for indexing access to a collection of key-value pairs, where type of key is String and type of value is Any?.

Exposes the JavaScript JSON object to Kotlin.

Adds prefix to external declarations in a source file.

Adds prefix to external declarations in a source file.

Exposes the TypeScript ReadonlyArray to Kotlin.

Exposes the TypeScript ReadonlyMap to Kotlin.

Exposes the TypeScript ReadonlySet to Kotlin.

JavaScript value that can serve as a reference for any Kotlin value.

Exposes the JavaScript Set to Kotlin.

Specifies that an additional static method is generated from the annotated companion object member if it's a function. If the member is a property, additional static getter/setter methods are generated.

JavaScript primitive string

Forces the compiler to generate compatibility accessors for the annotated class or interface.

Prevents the compiler from generating compatibility accessors for the annotated class or interface.

This annotation instructs the compiler to expose the API of functions with inline classes (and the classes containing them, including inline classes themselves) as their boxed variant for effective usage from Java.

Instructs the Kotlin compiler not to generate getters/setters for this property and expose it as a field.

Specifies that given value class is inline class.

Instructs the Kotlin compiler to generate a multifile class with top-level functions and properties declared in this file as one of its parts. Name of the corresponding multifile class is provided by the JvmName annotation.

Specifies the name for the Java class or method which is generated from this element.

Instructs the Kotlin compiler to generate overloads for this function that substitute default parameter values.

Instructs compiler to mark the class as a record and generate relevant toString/equals/hashCode methods

Makes the annotation class repeatable in Java and Kotlin. A repeatable annotation can be applied more than once on the same element.

Makes the annotated lambda function implement java.io.Serializable, generates a pretty toString implementation and adds reflection metadata.

Specifies that an additional static method needs to be generated from this element if it's a function. If this element is a property, additional static getter/setter methods should be generated.

Instructs compiler to generate or omit wildcards for type arguments corresponding to parameters with declaration-site variance, for example such as Collection<out T> has.

Sets ACC_SYNTHETIC flag on the annotated target in the Java bytecode.

Instructs compiler to generate wildcard for annotated type arguments corresponding to parameters with declaration-site variance.

Represents an annotated element and allows to obtain its annotations. See the Kotlin language documentation for more information.

Represents an annotated element and allows to obtain its annotations. See the Kotlin language documentation for more information.

Represents a callable entity, such as a function or a property.

Represents a class and provides introspection capabilities. Instances of this class are obtainable by the ::class syntax. See the Kotlin language documentation for more information.

A classifier is either a class or a type parameter.

Represents an entity which may contain declarations of any other entities, such as a class or a package.

Represents an entity which may contain declarations of any other entities, such as a class or a package.

Represents a function with introspection capabilities.

Represents a property declared as a var.

Represents a var-property without any kind of receiver.

Represents a var-property, operations on which take one receiver as a parameter.

Represents a var-property, operations on which take two receivers as parameters.

Represents a version of the Kotlin standard library.

Represents a parameter passed to a function or a property getter/setter, including this and extension receiver parameters.

Represents a property, such as a named val or var declaration. Instances of this class are obtainable by the :: operator.

Represents a property without any kind of receiver. Such property is either originally declared in a receiverless context such as a package, or has the receiver bound to it.

Represents a property, operations on which take one receiver as a parameter.

Represents a property, operations on which take two receivers as parameters, such as an extension property declared in a class.

Represents a type. Type is usually either a class with optional type arguments, or a type parameter of some declaration, plus nullability.

Represents a declaration of a type parameter of a class or a callable. See the Kotlin language documentation for more information.

Represents a type projection. Type projection is usually the argument to another type in a type usage. For example, in the type Array<out Number>, out Number is the covariant projection of the type represented by the class Number.

Represents variance applied to a type parameter on the declaration site (declaration-site variance), or to a type in a projection (use-site variance).

Visibility is an aspect of a Kotlin declaration regulating where that declaration is accessible in the source code. Visibility can be changed with one of the following modifiers: public, protected, internal, private.

Represents a value with lazy initialization.

Specifies how a Lazy instance synchronizes initialization and publication among multiple threads. On platforms with no notion of synchronization and threads (JS and WASM), all modes are considered equal to the default implementation.

Hash table based implementation of the MutableMap interface, which additionally preserves the insertion order of entries during the iteration.

The implementation of the MutableSet interface, backed by a InternalMap implementation.

A generic ordered collection of elements. Methods in this interface support only read-only access to the list; read/write access is supported through the MutableList interface.

An iterator over a collection that supports indexed access.

Represents a 64-bit signed integer.

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

An iterator over a sequence of values of type Long.

A progression of values of type Long.