Estimated time: about 10 minutes

This page lists core Kotlin terms in alphabetical order. Each term comes with a concise definition and a link to the related concept document.

Top 5 Core Terms

• Coroutine: A lightweight, suspendable asynchronous execution unit
• Data Class: An immutable data class that auto-generates equals/hashCode/copy
• Null Safety: A safety mechanism that distinguishes nullable (T?) and non-null (T) at the type level
• Sealed Class: Restricts subtypes to the same module/package and enables exhaustive when checking
• Extension Function: A way to add new functions to an existing type without modifying it

A#

Any

The top type of Kotlin’s type hierarchy. The common ancestor of all Kotlin objects. Defines equals(), hashCode(), and toString(). → Variables and Types

apply

One of the scope functions. Uses the receiver object as the context (this) and returns the receiver itself. Commonly used for object initialization patterns.

as? (safe cast)

An operator that attempts a type conversion and returns null on failure. Unlike a plain as, it does not throw ClassCastException. → Null Safety

B#

by (delegation keyword)

A keyword that delegates property or interface implementation to another object. Used as val x by lazy { ... }, class A : B by b.

buildList / buildMap / buildSet

Standard library functions for building read-only collections via a builder block. → Collections

C#

Companion Object

A singleton object declared inside a class. Accessible directly through the class name. Used for factory methods and constant definitions. → Classes and Objects

Component Function (componentN)

Functions auto-generated by data class. The foundation for destructuring declarations (val (a, b) = obj). → Data/Sealed Classes

Context Receiver

An experimental feature introduced in Kotlin 1.6. A way to declare multiple receiver objects in a function signature. → Version Comparison

Coroutine

A lightweight execution unit that can suspend and resume later. Much lighter than threads and supports Structured Concurrency. Started with launch, async, or runBlocking.

copy()

A function auto-generated by data class. Returns a new instance with some properties changed — the transformation pattern for immutable objects. → Data/Sealed Classes

A-C Key Points

• by: The delegation keyword, used with lazy, observable, and interface delegation
• companion object: Class-level factory/constants — distinct from the object declaration
• Coroutine: Lightweight asynchronous unit; thousands can run concurrently compared to threads

D#

Data Class

A class declared with the data keyword. Auto-generates equals, hashCode, toString, copy, and componentN. Suitable for immutable DTOs and value objects. → Data/Sealed Classes

Deferred

The type returned by the async { } coroutine builder. Represents a future result and is obtained via await().

Dispatchers

The context that determines which thread a coroutine runs on. Dispatchers.Main (main/UI), Dispatchers.IO (I/O), Dispatchers.Default (CPU).

E#

Elvis Operator (?:)

An operator that returns the right-hand value when a nullable expression is null. val name = rawName ?: "anonymous". → Null Safety

Expression

A unit of code that returns a value. In Kotlin, if, when, and try are all expressions. → Basics

Extension Function

A technique to add new functions to an existing class without modifying it or using inheritance. Form: fun ClassName.newFunction() { ... }. Standard library methods such as String.uppercase() and List.filter() are implemented as extension functions. → Extension Functions

F#

Flow

A coroutine-based asynchronous stream. A cold stream that emits multiple values sequentially. Hot stream variants such as StateFlow and SharedFlow also exist.

fun (function keyword)

The keyword for declaring Kotlin functions. Top-level, member, extension, and local functions are all declared with fun. → Functions

I#

inline

A keyword that causes a function’s body to be inserted at the call site. Mainly used for higher-order functions taking lambdas to eliminate object-creation overhead.

init block

A block of code that runs during class initialization. Executes right after the primary constructor and is used for validation or derived-property initialization. → Classes and Objects

internal

A visibility modifier accessible only within the same Gradle module. Useful for hiding the internal implementation of a library. → Classes and Objects

D-I Key Points

• Flow: A coroutine-based asynchronous stream; an alternative to RxJava
• inline: A performance optimization for lambda-based higher-order functions; used with reified
• internal: Module-level visibility that Java does not have

J#

@JvmOverloads

An annotation that auto-generates overloaded methods so Kotlin functions with default arguments can be called as overloads from Java.

@JvmStatic

An annotation that allows companion object members to be called as static methods from Java.

K#

K2 Compiler

A new compiler frontend stabilized in Kotlin 2.0. Faster compilation, more accurate type inference, and integrated IDE analysis. → Version Comparison

L#

lateinit

A keyword that defers the initialization of a non-null property. Only applies to var. Accessing before initialization throws UninitializedPropertyAccessException. → Classes and Objects

lazy

A delegate that creates a lazily-initialized property — initialized on first access. val x by lazy { ... }. Thread-safe by default. → Classes and Objects

let

One of the scope functions. Passes the receiver to the lambda as it and returns the lambda result. Mainly used for nullable handling and limiting variable scope.

N#

Nothing

A subtype of every type. The return type of functions that never return normally (throw exceptions, infinite loops). → Variables and Types

Null Safety

A type-system property that distinguishes nullable types (T?) from non-null types (T). Prevents NullPointerException at compile time. → Null Safety

O#

object

A keyword that defines a singleton instance. Handles class declaration and instance creation at once. Also used for anonymous object expressions. → Classes and Objects

J-O Key Points

• K2 Compiler: The core of Kotlin 2.0 — faster compilation and more accurate analysis
• lateinit vs lazy: var/manual initialization vs val/init on first access
• Nothing: The type for functions that throw exceptions; the bottom of the type hierarchy

R#

reified

A keyword that allows access to the actual runtime type information of a type parameter inside an inline function. inline fun <reified T> ...

Receiver

The object accessed as this in an extension function or a lambda with receiver. The heart of the DSL builder pattern.

S#

Sealed Class / Sealed Interface

A class/interface that restricts its subtypes to the same module and same package (Kotlin 1.5+). Supports exhaustive checks with when. → Data/Sealed Classes

Sequence

A lazily-evaluated collection. Processes elements one-by-one through a pipeline without creating intermediate collections. Efficient for large datasets. → Collections

Structured Concurrency

A principle that structures coroutine lifecycles around CoroutineScope so there are no leaks or unfinished tasks.

suspend

A keyword for suspend functions that can only be called inside a coroutine. Suspends execution without blocking the thread.

U#

Unit

The return type of functions that have no return value. Corresponds to Java’s void but is an actual type (a singleton value). Can be omitted. → Variables and Types

V#

val / var

val declares an immutable (read-only) variable; var declares a mutable variable. Prefer val by default. → Variables and Types

Value Class

Declared as @JvmInline value class. Wraps a single property but does not create a wrapper object at runtime — an inline class.

vararg

A parameter keyword for receiving a variable number of arguments. Treated as an array inside the function. Passed using the spread operator (*). → Functions

R-V Key Points

• reified: Retains generic type information at runtime; can be used only with inline
• suspend: A core coroutine keyword; asynchronous without blocking the thread
• value class: A type-safe wrapper with no runtime overhead

W#

when

Kotlin’s branching expression. More powerful than switch, supporting type checks, ranges, and various conditional patterns. Performs exhaustive checks with sealed class. → Basics

Next Steps#

• Concepts - Detailed documents on Kotlin core concepts
• Version Comparison - Changes from Kotlin 1.x to 2.x
• FAQ - Frequently asked questions
• References - Official documentation and learning resources