Adds or appends the value on its righthand side to the element on its lefthand side: +=
A type that allows the representation of a closed set of possible subtypes, such as an enumerated class.
(See also class, enumerated; class, sealed)
The starting place for a program. In Kotlin, this is the main function.
An input to a function.
A value assigned to a function argument to be used if no value is provided by the caller.
A function argument assigned a name that can be used by the caller.
Operator used in lambda expressions to separate parameters from the function body, in when expressions to separate the condition from the result, and in function type definitions to separate parameter types from result types: ->
Assigns the value on its righthand side to the element on its lefthand side: =
A set of code executed conditionally.
The lower-level language used by the Java Virtual Machine.
Called on a receiver that is scoped but not specified.
(See also scoping, relative)
A definition of a category of objects represented in code.
The portion of a class definition, designated by curly braces, that holds its behavior and data definitions.
A function defined within a class.
An attribute required to represent the state or characteristics of an object.
A class that is never instantiated but is used to create common features among its subclasses.
A class with special features for data management.
A class defining a collection of constants called enumerated types; all instances of the class are of one of the defined types. Compared to a sealed class, an enumerated class prohibits inheritance, and its subclasses cannot contain different states or have multiple instances.
(See also class, sealed; type, enumerated)
A named class defined within another class.
A class with a defined set of subtypes, allowing the compiler to check whether a when expression contains an exhaustive set of branches. Compared to an enumerated class, a sealed class permits inheritance, and its subclasses can contain different states and can have multiple instances.
(See also algebraic data type; class, enumerated)
Another term for a Kotlin anonymous function. Anonymous functions in Kotlin may reference local variables defined in the scope outside of the anonymous function because they persist, or “close over,” local variables they reference.
(See also function, anonymous)
A note in code; comments are ignored by the compiler.
A collection whose values are accessible when it is instantiated.
(See also collection, lazy)
A collection whose values are produced only as needed.
(See also collection, eager; function, iterator)
An operator that compares the elements on its lefthand and righthand sides.
The translation of source code into a lower-level language to create an executable program.
See compilation.
An error that occurs during compilation.
(See also compilation)
A language that is translated into machine-language instructions prior to processing by a compiler.
(See also compilation; compiler)
A program that performs compilation.
(See also compilation)
A conditional statement assigned to a value that can be used later.
A pane in the IntelliJ IDEA window that displays information about what happened when a program was executed, along with any outputs from the program. Also called the run tool window.
An element that holds a value that cannot be changed.
A special function that prepares a class for use during instantiation.
A class constructor defined in the class header.
A generic parameter that is writeable but not readable.
Marking a generic parameter as a consumer.
Rules for when code should be executed.
Experimental Kotlin feature that allows work to be performed in the background.
Marking a generic parameter as a producer.
A way of defining a template for property initialization.
Declaring and assigning multiple variables in a single expression.
Syntax that connects two elements with a dot (.); used when calling a function defined on a type and when referring to a class property.
The main area of the IntelliJ IDEA window, where code can be entered and edited.
The principle that an object's functions and properties should be visible to other objects only as needed. Also the process of hiding function and property implementations using visibility modifiers.
Of two variables: referring to the same type instance.
(See also equality, structural)
Of two variables: having the same value.
(See also equality, referential)
Distinguishes characters that have special meaning to the compiler: \
A pane in the IntelliJ IDEA window that displays information about what IntelliJ did to make a program ready to run.
A disruption to the execution of a program; an error.
An exception generated by code that is not wrapped in a try/catch statement.
An exception that is not managed in the codebase.
A combination of values, operators, and functions that produces another value.
Gain functionality through inheritance or interface implementation.
A property or function added to an object without inheritance.
Storage for the data associated with a property.
A number represented using a decimal that can be positioned at an arbitrary place based on its significant digits.
A reusable portion of code that accomplishes a specific task.
The portion of a function definition, designated by curly braces, that holds its behavior definitions and return type.
A line of code that triggers a function and passes it any necessary arguments.
A function call that returns its receiver or another object that a subsequent function can be called on.
The part of a function definition that includes the visibility modifier, function declaration keyword, name, parameters, and return type.
A compiler optimization commonly used to reduce the memory overhead for functions that accept anonymous functions as arguments.
Defining two or more function implementations with the same name and scope but different parameters.
A named function converted to a value that can be passed as an argument.
The type of an anonymous function, defined by its input, output, and parameters.
A function declared without an implementation in an abstract class.
(See also class, abstract)
A function defined without a name; often used as an argument to another function.
(See also function, named)
A function that takes multiple collections and combines them into a single new collection.
A function that can be combined with other functions.
A function that adds functionality to a particular type.
A function that works on the contents of a collection by applying a predicate function to check a condition for each element; elements for which the predicate returns true are added to a new collection returned by the filter function.
A function referred to each time a value is requested from a lazy collection.
A function that changes the contents of a mutable collection.
A function defined with a name.
(See also function, anonymous)
A Kotlin standard library function that defines conditions that must be met before some code is executed.
A function with a single expression.
(See also expression)
In functional programming, a function that works on the contents of a collection by transforming each element using its transformer function; transform functions return a modified copy of the collection they are called on.
(See also functional programming)
In functional programming, the anonymous function passed to a transform function that specifies the action to be taken on each element in the collection the transform is called on.
(See also functional programming)
A style of programming that relies on higher-order functions, designed to work on collections, that are chained to create complex behavior.
A class that accepts a generic input - i.e., an input of any type.
The parameter specified for a generic type, such as <T>.
A type system feature that allows functions and types to work with unknown types.
A function defining how a property is read.
A function that takes another function as an argument.
The programming paradigm that includes object-oriented programming.
Adds 1 to the value of the element it is affixed to: ++
An integer corresponding to the position of an element in a series.
Gets the element at a particular index from a collection: []
An object-oriented programming principle in which the properties and behavior of classes are shared by their subclasses.
Preparation of a variable, property, or class instance for use.
Initialization of a variable that is delayed until its value is assigned.
Initialization of a variable that is delayed until it is first accessed.
A block of code, prefixed with init, that will be executed during initialization of an object instance.
A particular occurrence of an object.
Create an instance of.
A set of abstract functions and properties used to create common features among objects not related by inheritance.
Interact with another programming language natively.
Repeating a process, as for each element in a range or collection.
A tool in IntelliJ IDEA that allows code to be tested without creating a file or running a complete program.
A set of extension functions available for use with any Kotlin type.
Another term for an anonymous function.
(See also function, anonymous)
Another term for an anonymous function's definition.
(See also function, anonymous)
Another term for an anonymous function's return.
(See also function, anonymous)
A function or operator symbol that performs a logical operation on its input(s).
Returns true if and only if the elements on its lefthand and righthand sides are both true: &&
Returns true if either of the elements on its lefthand and righthand sides is true: ||
Java terminology for a function.
(See also function)
A discrete unit of functionality that can be run, tested, and debugged independently.
Returns the remainder when one number is divided by another; also called the remainder operator: %
Able to be changed.
(See also read-only)
Calls a function on a nullable element, returning an exception if the element it is called on is null: !!
Unable to be assigned a null value.
Nonexistent.
Returns the element on its lefthand side if it is non-null; otherwise returns the element on its righthand side: ?:
Able to be assigned a null value.
A named singleton created with the object keyword.
(See also object, companion; object expression; singleton)
An unnamed singleton created with the object keyword.
(See also object, companion; object declaration; singleton)
An object defined within a class and marked with the companion modifier; companion objects allow their members to be accessed by referencing the outer class name only.
(See also object declaration; object expression; singleton)
Defining an implementation for an operator function on a custom type.
Provide a custom implementation for an inherited function or property.
An input required by a function.
The type defined for the contents of a collection.
Provide an input to a function.
Ambiguous types returned to Kotlin from Java code; they may be nullable or non-nullable.
The ability to use the same named entity (such as a function) to produce different results.
A true/false condition provided to a function as a lambda to define how work should be performed.
A generic parameter that is readable but not writeable.
All the source code for a program, along with information about dependencies and configurations.
The pane on the left of the IntelliJ IDEA window that shows a project's structure and files.
A property defined such that its value is computed each time it is accessed.
A class property defined in the primary constructor.
A condition that occurs when some state is modified simultaneously by two or more elements in a program.
A sequential series of values or characters.
Able to be read but not changed.
(See also mutable)
The subject of an extension function.
The type an extension adds functionality to.
Change the presentation or location of code without changing its functionality.
Evaluates whether the variable on its lefthand side points to the same type instance as the value on its righthand side: ===
(See also equality, referential)
Learning the name or type of a property at runtime.
(See also type erasure)
A defined character search pattern.
See modulus operator.
A word that cannot be used as a function name.
The type of output data a function returns after completing its work.
Data that is returned without an explicit return statement.
A pane in the IntelliJ IDEA window that displays information about what happened when a program was executed along with any outputs from the program. Also called the console.
When a program is executed.
An error that occurs after compilation, during program execution.
Calls a function only if the element it is called on is non-null: ?.
The portion of a program in which an entity, such as a variable, can be referred to by name.
The scoping of standard function calls within a lambda to the receiver the lambda is called on.
(See also called on, implicitly)
A function defining how a property's value is assigned.
A numeric type that includes both positive and negative values.
An object declared with the object keyword; singletons are limited to a single instance throughout program execution.
The tracking by the compiler of information that has been checked for a branch of code, such as whether a variable has a null value.
An instruction in code.
A sequence of characters.
Combining two or more strings in a single output.
Using a string template.
Syntax that allows a variable name to stand in for its value in a string.
Evaluates whether the value on its lefthand side is equal to the value on its righthand side: ==
(See also equality, structural)
A class defined as inheriting properties from another class.
The class that a subclass inherits from.
Design a program to run on a platform.
Generate an exception.
A classification of data; a variable's type determines the nature of the values it can hold.
Treating an object as though it were an instance of a different type.
Confirmation by the compiler that the value assigned to a variable is of the correct type.
Type checking performed as code is entered or edited.
The loss of type information for generics at runtime.
The ability of the compiler to recognize a variable's type based on the value assigned to it.
A system in which the compiler labels source code with type information for checking.
A type defined as one of the elements of an enumerated class.
(See also class, enumerated)
Data types that represent groups of data elements, such as lists.
A character defined in the Unicode system.
An element that holds a value; variables may be read-only or mutable.
A variable defined outside of any function or class.
A variable defined within a function's scope.
The accessibility of an element from other code elements.
A modifier added to function and property declarations to set their visibility.
Using the value 0 for the first index (in a series or collection).