kotlin-stdlib

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 MutableList 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.

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.

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.

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.

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

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.

Represents a 16-bit Unicode character.

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

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.

Represents a range of values (for example, numbers or characters). See the Kotlin language documentation for more information.

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.

Standard property delegates.

Marks the annotated declaration as deprecated.

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

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.

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.

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

The experimental multiplatform support API marker.

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

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.

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. On the JVM, non-nullable values of this type are represented as values of the primitive type float.

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.

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

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

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

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.

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.

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

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

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

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.

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.

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 the Kotlin compiler to generate overloads for this function that substitute default parameter values.

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.

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.

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.

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.

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 a callable entity, such as a function or a property.

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.

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.

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 function with introspection capabilities.

Represents a property declared as a var.

Represents a property declared as a var.

Represents a var-property without any kind of receiver.

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 one receiver as a parameter.

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

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

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, 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 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 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 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 type. Type is usually either a class with optional type arguments, or a type parameter of some declaration, plus nullability.

Represents a value with lazy initialization.

Specifies how a Lazy instance synchronizes initialization among multiple threads.

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. On the JVM, non-nullable values of this type are represented as values of the primitive type long.

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.

A range of values of type Long.

A collection that holds pairs of objects (keys and values) and supports efficiently retrieving the value corresponding to each key. Map keys are unique; the map holds only one value for each key. Methods in this interface support only read-only access to the map; read-write access is supported through the MutableMap interface.

Represents the results from a single capturing group within a MatchResult of Regex.

Represents a collection of captured groups in a single match of a regular expression.

Represents the results from a single regular expression match.

This meta-annotation determines that an annotation is a part of public API and therefore should be included in the generated documentation for the element to which the annotation is applied.

A generic collection of elements that supports adding and removing elements.

Classes that inherit from this interface can be represented as a sequence of elements that can be iterated over and that supports removing elements during iteration.

An iterator over a mutable collection. Provides the ability to remove elements while iterating.

A generic ordered collection of elements that supports adding and removing elements.

An iterator over a mutable collection that supports indexed access. Provides the ability to add, modify and remove elements while iterating.

A modifiable collection that holds pairs of objects (keys and values) and supports efficiently retrieving the value corresponding to each key. Map keys are unique; the map holds only one value for each key.

A generic unordered collection of elements that does not support duplicate elements, and supports adding and removing elements.

An exception class which is used when file to copy does not exist.

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).

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

Superclass for all platform classes representing numeric values.

Implements the core logic of a property delegate for a read/write property that calls callback functions when changed.

Enum that can be used to specify behaviour of the copyRecursively() function in exceptional conditions.

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

Represents a generic pair of two values.

Instructs the Kotlin compiler to treat annotated Java class as pure implementation of given Kotlin interface. "Pure" means here that each type parameter of class becomes non-platform type argument of that interface.

Base interface that can be used for implementing property delegates of read-only properties.

Base interface that can be used for implementing property delegates of read-write properties.

Represents a compiled regular expression. Provides functions to match strings in text with a pattern, replace the found occurrences and split text around matches.

Provides enumeration values to use to set regular expression options.

This meta-annotation determines that an annotation is applicable twice or more on a single code element

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.

This meta-annotation determines whether an annotation is stored in binary output and visible for reflection. By default, both are true.

A sequence that returns values through its iterator. The values are evaluated lazily, and the sequence is potentially infinite.

A generic unordered collection of elements that does not support duplicate elements. Methods in this interface support only read-only access to the set; read/write access is supported through the MutableSet interface.

Marks a top level property with a backing field as immutable. It is possible to share the value of such property between multiple threads, but it becomes deeply frozen, so no changes can be made to its state or the state of objects it refers to.

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

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

An iterator over a sequence of values of type Short.

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.

Marks the JVM method generated from the annotated function as strictfp, meaning that the precision of floating point operations performed inside the method needs to be restricted in order to achieve better portability.

Marks the JVM method generated from the annotated function as strictfp, meaning that the precision of floating point operations performed inside the method needs to be restricted in order to achieve better portability.

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

Suppresses the given compilation warnings in the annotated element.

Marks the JVM method generated from the annotated function as synchronized, meaning that the method will be protected from concurrent execution by multiple threads by the monitor of the instance (or, for static methods, the class) on which the method is defined.

Marks the JVM method generated from the annotated function as synchronized, meaning that the method will be protected from concurrent execution by multiple threads by the monitor of the instance (or, for static methods, the class) on which the method is defined.

This meta-annotation indicates the kinds of code elements which are possible targets of an annotation.

Marks a top level property with a backing field or an object as thread local. The object remains mutable and it is possible to change its state, but every thread will have a distinct copy of this object, so changes in one thread are not reflected in another.

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

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

Marks the JVM backing field of the annotated property as transient, meaning that it is not part of the default serialized form of the object.

Marks the JVM backing field of the annotated property as transient, meaning that it is not part of the default serialized form of the object.

Represents a triad of values

Defines names for Unicode symbols used in proper Typography.

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

Suppresses errors about variance conflict

Marks the JVM backing field of the annotated property as volatile, meaning that writes to this field are immediately made visible to other threads.

Marks the JVM backing field of the annotated property as volatile, meaning that writes to this field are immediately made visible to other threads.