Kotlin

Advanced Kotlin Features Example:

// Coroutines example with structured concurrency
suspend fun fetchData(): Result<Data> = coroutineScope {
    val part1 = async { api.fetchPart1() }
    val part2 = async { api.fetchPart2() }
    
    try {
        Result.success(combineData(part1.await(), part2.await()))
    } catch (e: Exception) {
        Result.failure(e)
    }
}

// Extension function with reified type parameter
inline fun <reified T> Bundle.getParcelable(key: String): T? {
    return if (SDK_INT >= 33) {
        getParcelable(key, T::class.java)
    } else {
        @Suppress("DEPRECATION")
        getParcelable(key) as? T
    }
}

// Property delegation using a custom delegate
class User {
    var name: String by Delegates.observable("") { _, old, new ->
        log("Name changed from $old to $new")
    }
    
    var email: String by EmailDelegate()
}
        

Declaration Syntax Comparison:

// Kotlin declarations with type inference
val immutable: String = "explicit type"  // Immutable with explicit type
val inferred = "type inferred"           // Type inference for immutable
var mutable = 100                        // Mutable with inference

// Java equivalent
final String immutable = "explicit type";
String inferred = "type inferred";       // Not actually inferred in Java
int mutable = 100;

// Kotlin nullability - a core syntax feature
val cannotBeNull: String = "value"       // Non-nullable by default
val canBeNull: String? = null            // Explicitly nullable
val safeCall = canBeNull?.length         // Safe call operator
val elvisOp = canBeNull?.length ?: 0     // Elvis operator

// Function declaration syntax
fun basic(): String = "Simple return"    // Expression function
fun withParams(a: Int, b: String = "default"): Boolean {  // Default parameters
    return a > 10                        // Function body
}
        

Expression-Oriented Features:

// if as an expression
val max = if (a > b) a else b

// when as a powerful pattern matching expression
val description = when (obj) {
    is Int -> "An integer: $obj"
    in 1..10 -> "A number from 1 to 10"
    is String -> "A string of length ${obj.length}"
    is List<*> -> "A list with ${obj.size} elements"
    else -> "Unknown object"
}

// try/catch as an expression
val result = try {
    parse(input)
} catch (e: ParseException) {
    null
}

// Extension functions - a unique Kotlin feature
fun String.addExclamation(): String = this + "!"
println("Hello".addExclamation())  // Prints: Hello!

// Infix notation for more readable method calls
infix fun Int.isMultipleOf(other: Int) = this % other == 0
println(15 isMultipleOf 5)  // Prints: true
        

Functional Syntax Comparison:

// Lambda expressions in Kotlin
val sum = { x: Int, y: Int -> x + y }
val result = sum(1, 2)  // 3

// Higher-order functions
fun <T, R> Collection<T>.fold(
    initial: R, 
    operation: (acc: R, element: T) -> R
): R {
    var accumulator = initial
    for (element in this) {
        accumulator = operation(accumulator, element)
    }
    return accumulator
}

// Type-safe builders (DSL-style syntax)
val html = html {
    head {
        title { +"Kotlin DSL Example" }
    }
    body {
        h1 { +"Welcome" }
        p { +"This is a paragraph" }
    }
}

// Function references with ::
val numbers = listOf(1, 2, 3)
numbers.filter(::isPositive)

// Destructuring declarations
val (name, age) = person
        

Advanced OOP Syntax:

// Class declaration with primary constructor
class Person(val name: String, var age: Int) {
    // Property with custom getter
    val isAdult: Boolean
        get() = age >= 18
        
    // Secondary constructor
    constructor(name: String) : this(name, 0)
    
    // Concise initializer block
    init {
        require(name.isNotBlank()) { "Name cannot be blank" }
    }
}

// Data classes - automatic implementations
data class User(val id: Int, val name: String)

// Sealed classes - restricted hierarchies
sealed class Result {
    data class Success(val data: Any) : Result()
    data class Error(val message: String) : Result()
}

// Object declarations - singletons
object DatabaseConnection {
    fun connect() = println("Connected")
}

// Companion objects - factory methods and static members
class Factory {
    companion object {
        fun create(): Factory = Factory()
    }
}

// Extension properties
val String.lastChar: Char get() = this[length - 1]
        

Bit Representation and Ranges:

println(Int.MIN_VALUE)    // -2147483648
println(Int.MAX_VALUE)    // 2147483647
println(Float.MIN_VALUE)  // 1.4E-45
println(Double.MAX_VALUE) // 1.7976931348623157E308
        

Explicit Conversions:

val intValue: Int = 100
// val longValue: Long = intValue  // Type mismatch: won't compile
val longValue: Long = intValue.toLong()  // Correct way to convert
        

val char: Char = 'A'
// val ascii: Int = char  // Type mismatch: won't compile
val ascii: Int = char.code  // Correct way to get the numeric code
val fromCode: Char = 65.toChar()  // Converting back to Char
        

val escaped = "Line 1\nLine 2"
val raw = """
    SELECT *
    FROM users
    WHERE id = 1
""".trimIndent()
        

val name = "Kotlin"
val version = 1.5
println("I'm coding in $name $version")  // Simple variable reference
println("The result is ${2 + 2}")  // Expression in curly braces
        

var nonNull: String = "value"
// nonNull = null  // Compilation error

// To allow null, use the nullable type with ?
var nullable: String? = "value"
nullable = null  // OK
        

val a: Int = 100  // At runtime, uses Java's primitive int when possible
val b: Int? = 100 // Uses Integer because it needs to represent null
val list: List<Int> = listOf(1, 2, 3)  // Uses Integer in collections
        

// Numeric literals and type inference
val decimalLiteral = 123     // Int
val longLiteral = 123L       // Long
val hexLiteral = 0x0F        // Int (15 in decimal)
val binaryLiteral = 0b00001  // Int (1 in decimal)
val readableLiteral = 1_000_000  // Underscores for readability, still Int

// Explicit conversions
val byte: Byte = 1
val int: Int = byte.toInt()
val float: Float = int.toFloat()
        

// Boolean operations
val a = true
val b = false
val conjunction = a && b            // false
val disjunction = a || b            // true
val negation = !a                   // false
val shortCircuitEvaluation = a || expensiveOperation()  // expensiveOperation() won't be called
        

// String manipulation and features
val name = "Kotlin"
val version = 1.5
val template = "I use $name $version"  // Variable references
val expression = "The result is ${2 + 2}"  // Expression embedding

// Raw string for regex pattern (no escaping needed)
val regex = """
    \d+      # one or more digits
    \s+      # followed by whitespace
    \w+      # followed by word characters
""".trimIndent()

// String utilities from standard library
val sentence = "Kotlin is concise"
println(sentence.uppercase())    // "KOTLIN IS CONCISE"
println(sentence.split(" "))     // [Kotlin, is, concise]
println("k".repeat(5))           // "kkkkk"
        

// Generic array
val array = Array(5) { i -> i * i }  // [0, 1, 4, 9, 16]

// Specialized primitive arrays (more memory efficient)
val intArray = IntArray(5) { it * 2 }       // [0, 2, 4, 6, 8]
val charArray = CharArray(3) { 'A' + it }   // ['A', 'B', 'C']

// Arrays in Kotlin have fixed size
println(array.size)  // 5
// array.size = 6    // Error - size is read-only

// Performance comparison
fun benchmark() {
    val boxedArray = Array(1000000) { it }      // Boxed integers
    val primitiveArray = IntArray(1000000) { it }  // Primitive ints
    
    // primitiveArray operations will be faster
}
        

// Immutable collections (read-only interfaces)
val readOnlyList = listOf(1, 2, 3, 4)
val readOnlySet = setOf("apple", "banana", "cherry")
val readOnlyMap = mapOf("a" to 1, "b" to 2)

// Mutable collections
val mutableList = mutableListOf(1, 2, 3)
mutableList.add(4)  // Now [1, 2, 3, 4]

val mutableMap = mutableMapOf("one" to 1, "two" to 2)
mutableMap["three"] = 3  // Add new entry

// Converting between mutable and immutable views
val readOnlyView: List = mutableList  // Upcasting to read-only type
// But the underlying list can still be modified through the mutableList reference

// Advanced collection operations
val numbers = listOf(1, 2, 3, 4, 5)
val doubled = numbers.map { it * 2 }       // [2, 4, 6, 8, 10]
val even = numbers.filter { it % 2 == 0 }  // [2, 4]
val sum = numbers.reduce { acc, i -> acc + i }  // 15
        

fun functionName(param1: Type1, param2: Type2): ReturnType {
    // function body
    return result
}
        

Higher-Order Function Example:

// A function that takes another function as a parameter
fun executeOperation(x: Int, y: Int, operation: (Int, Int) -> Int): Int {
    return operation(x, y)
}

// Using the higher-order function with a lambda
val sum = executeOperation(5, 3) { a, b -> a + b }  // 8
val product = executeOperation(5, 3) { a, b -> a * b }  // 15
        

Extension Function Example:

// Adding a new function to the String class
fun String.removeFirstAndLast(): String {
    return if (length <= 2) "" else substring(1, length - 1)
}

// Using the extension function
val result = "Hello".removeFirstAndLast()  // "ell"
        

Local Function Example:

fun processInput(input: String): String {
    // Local function defined within another function
    fun validate(value: String): Boolean {
        return value.isNotEmpty() && value.length < 100
    }
    
    // Using the local function
    return if (validate(input)) {
        "Input is valid: $input"
    } else {
        "Invalid input"
    }
}
        

inline fun measureTime(action: () -> Unit): Long {
    val startTime = System.currentTimeMillis()
    action()
    return System.currentTimeMillis() - startTime
}
        

// Complete syntax
fun [receiver_type].[function_name]([parameters]): [return_type] {
    // function body
    return [expression]
}
        

// Explicit return type
fun multiply(a: Int, b: Int): Int {
    return a * b
}

// Inferred return type with single-expression function
fun multiply(a: Int, b: Int) = a * b

// Unit return type (can be explicit or implicit)
fun logMessage(message: String): Unit {
    println(message)
}

// Nothing return type
fun fail(message: String): Nothing {
    throw IllegalStateException(message)
}
        

fun connect(
    host: String = "localhost",
    port: Int = 8080,
    secure: Boolean = false,
    timeout: Int = 5000
) {
    // Connection logic
}

// Different ways to call
connect()
connect("example.com")
connect("example.com", 443, true)
connect(port = 9000, secure = true)
        

fun reformat(
    str: String,
    normalizeCase: Boolean = true,
    upperCaseFirstLetter: Boolean = true,
    divideByCamelHumps: Boolean = false,
    wordSeparator: Char = ' '
) {
    // Implementation
}

// Using named parameters
reformat(
    str = "This is a string",
    normalizeCase = false,
    wordSeparator = '_'
)
        

fun printAll(vararg messages: String) {
    for (message in messages) println(message)
}

// Call with multiple arguments
printAll("Hello", "World", "Kotlin")

// Spread operator (*) for arrays
val array = arrayOf("a", "b", "c")
printAll(*array)

// Mixing vararg with other parameters
fun formatAndPrint(prefix: String, vararg items: Any) {
    for (item in items) println("$prefix $item")
}
        

// Function that takes a function as parameter
fun processNumber(value: Int, transformer: (Int) -> Int): Int {
    return transformer(value)
}

// Using with various function parameters
val doubled = processNumber(5) { it * 2 }    // 10
val squared = processNumber(5) { it * it }   // 25
        

// Function that takes a Pair parameter and destructures it
fun processCoordinate(coordinate: Pair): Int {
    val (x, y) = coordinate  // Destructuring
    return x + y
}

// Can be rewritten with destructuring in parameter
fun processCoordinate(pair: Pair): Int {
    return pair.first + pair.second
}
        

// Normal inline function with lambda parameter
inline fun performAction(action: () -> Unit) {
    println("Before action")
    action()
    println("After action")
}

// Prevents non-local returns in lambda
inline fun executeWithCallback(
    crossinline callback: () -> Unit
) {
    Thread(Runnable { callback() }).start()
}

// Prevents inlining specific lambda parameter
inline fun executeMultipleActions(
    action1: () -> Unit,
    noinline action2: () -> Unit  // Will not be inlined
) {
    action1()
    Thread(Runnable { action2() }).start()
}
        

// Function with operator parameter
operator fun Int.plus(other: Int): Int {
    return this + other
}

// Function with reified type parameter (only in inline functions)
inline fun  typeOf() = T::class
        

// Basic class declaration
class Person {
    // Class body
}

// Class with visibility modifier
internal class InternalComponent {
    // Visible within the same module
}
        

// Primary constructor with parameters
class Person(val name: String, var age: Int) {
    // Properties are declared and initialized in the primary constructor
    
    // Initialization block
    init {
        require(age >= 0) { "Age cannot be negative" }
    }
    
    // Secondary constructor
    constructor(name: String) : this(name, 0) {
        println("Secondary constructor called")
    }
}
        

val person = Person("Alice", 30) // No 'new' keyword

// Reference comparison
val p1 = Person("Bob", 25)
val p2 = Person("Bob", 25)
println(p1 === p2) // false - different objects in memory
        

data class User(val id: Int, val name: String)

val user = User(1, "John")
val copy = user.copy(name = "Jane") // Easy copying with partial changes

// Destructuring declaration
val (id, name) = user
        

sealed class Result {
    data class Success(val data: String) : Result()
    data class Error(val message: String) : Result()
    object Loading : Result()
}

// Exhaustive when expression (compiler enforces handling all cases)
fun handleResult(result: Result) = when(result) {
    is Result.Success -> display(result.data)
    is Result.Error -> showError(result.message)
    is Result.Loading -> showLoadingIndicator()
    // No 'else' branch needed - compiler knows all possible types
}
        

// Singleton object
object Logger {
    private val logs = mutableListOf()
    
    fun log(message: String) {
        logs.add("[${System.currentTimeMillis()}] $message")
    }
    
    fun printLogs() {
        logs.forEach(::println)
    }
}

// Usage
Logger.log("Application started")
        

val clickListener = object : OnClickListener {
    override fun onClick(view: View) {
        // Handle click
    }
}
        

class MyClass {
    companion object Factory {
        fun create(): MyClass = MyClass()
    }
}

// Can be called using the class name
val instance = MyClass.create()
        

Property Declaration and Types:

class User {
    // Basic property declarations
    var mutableProperty: String = "Can be changed"       // Read-write property
    val immutableProperty: Int = 42                      // Read-only property
    lateinit var lazyInitialized: SomeClass              // Initialized later (no null check needed after init)
    var nullableProperty: Double? = null                 // Can hold null
    
    // Delegated properties
    val lazy: ComplexObject by lazy { createComplexObject() }  // Created on first access
    var observable: Int by Delegates.observable(0) { _, old, new ->
        println("Changed from $old to $new")
    }
    
    // Late-initialized property (used in Android/frameworks)
    private lateinit var adapter: RecyclerAdapter
}
        

class Temperature {
    // Property with custom accessors
    var celsius: Float = 0f
        set(value) {
            // Validate before setting
            require(value > -273.15f) { "Temperature below absolute zero" }
            field = value  // 'field' is the backing field
            _fahrenheit = celsius * 9/5 + 32  // Update dependent property
        }
        get() = field  // Explicit getter (could be omitted)
    
    // Backing property pattern
    private var _fahrenheit: Float = 32f
    val fahrenheit: Float 
        get() = _fahrenheit
    
    // Computed property (no backing field)
    val kelvin: Float
        get() = celsius + 273.15f
}
        

class TextProcessor {
    // Basic method
    fun process(text: String): String {
        return text.trim().capitalize()
    }
    
    // Extension function within a class
    fun String.wordCount(): Int = split(Regex("\\s+")).count()
    
    // Infix notation for more readable method calls
    infix fun append(other: String): String {
        return this.toString() + other
    }
    
    // Operator overloading
    operator fun plus(other: TextProcessor): TextProcessor {
        // Implementation
        return TextProcessor()
    }
    
    // Higher-order function with lambda parameter
    fun transform(text: String, transformer: (String) -> String): String {
        return transformer(text)
    }
}

// Usage examples
val processor = TextProcessor()
val result = processor process "some text"  // Infix notation
val combined = processor + anotherProcessor // Operator overloading
val transformed = processor.transform("text") { it.uppercase() }
        

Primary and Secondary Constructors:

// Class with primary constructor
class User(
    val id: Long,                    // Declares property + initializes from constructor param
    val username: String,            // Same for username
    private var _hashedPassword: String, // Private backing property
    email: String                    // Constructor parameter (not a property without val/var)
) {
    // Property initialized from constructor parameter
    val emailDomain: String = email.substringAfter("@")
    
    // Secondary constructor
    constructor(id: Long, username: String) : this(
        id, username, "", "$username@example.com"
    ) {
        println("Created user with default values")
    }
    
    // Initialization blocks execute in order of appearance
    init {
        require(username.length >= 3) { "Username too short" }
        println("First init block runs after primary constructor")
    }
    
    // Another init block
    init {
        println("Second init block runs")
    }
}
        

Initialization Demonstration:

class Demo {
    // 1. This initializer runs first
    val first = println("First property initializer")
    
    // 4. This init block runs fourth
    init {
        println("First initializer block")
    }
    
    // 2. This initializer runs second
    val second = println("Second property initializer")
    
    // 5. This constructor runs last if Demo() is called
    constructor() : this(42) {
        println("Secondary constructor")
    }
    
    // 3. Primary constructor called before init blocks
    constructor(value: Int) {
        println("Primary constructor with $value")
    }
    
    // 6. This init block runs fifth
    init {
        println("Second initializer block")
    }
}
        

class HttpRequest private constructor(
    val url: String,
    val method: String,
    val headers: Map,
    val body: String?
) {
    class Builder {
        private var url: String = ""
        private var method: String = "GET"
        private var headers: MutableMap = mutableMapOf()
        private var body: String? = null
        
        fun url(url: String) = apply { this.url = url }
        fun method(method: String) = apply { this.method = method }
        fun header(key: String, value: String) = apply { this.headers[key] = value }
        fun body(body: String) = apply { this.body = body }
        
        fun build(): HttpRequest {
            require(url.isNotEmpty()) { "URL cannot be empty" }
            return HttpRequest(url, method, headers, body)
        }
    }
    
    companion object {
        fun builder() = Builder()
    }
}

// Usage
val request = HttpRequest.builder()
    .url("https://api.example.com")
    .method("POST")
    .header("Content-Type", "application/json")
    .body("{\"key\": \"value\"}")
    .build()
        

class DatabaseConnection private constructor(val connection: Connection) {
    companion object Factory {
        private val pool = mutableListOf()
        
        fun create(url: String, user: String, password: String): DatabaseConnection {
            // Reuse connection from pool or create new one
            val existing = pool.find { it.url == url && !it.isClosed() }
            return if (existing != null) {
                DatabaseConnection(existing)
            } else {
                val newConnection = DriverManager.getConnection(url, user, password)
                pool.add(newConnection)
                DatabaseConnection(newConnection)
            }
        }
    }
}

// Usage
val db = DatabaseConnection.create("jdbc:mysql://localhost:3306/mydb", "user", "pass")
        

class ResourceManager {
    // Basic lazy property - thread-safe by default
    val heavyResource: Resource by lazy {
        println("Initializing heavy resource...")
        loadResource()
    }
    
    // Custom lazy implementation with options
    val configuredResource by lazy(LazyThreadSafetyMode.PUBLICATION) {
        loadResource()
    }
    
    // Using lateinit for non-null references initialized later
    lateinit var frameworkProvidedResource: Resource
    
    // Check if lateinit property has been initialized
    fun isResourceReady(): Boolean = ::frameworkProvidedResource.isInitialized
    
    private fun loadResource(): Resource {
        // Expensive operation
        Thread.sleep(1000)
        return Resource()
    }
}
        

Type System Implementation:

Kotlin's type system distinguishes between nullable references (that can hold null) and non-nullable references (that cannot hold null). A regular type T cannot hold null, while a nullable type T? can hold null:

var a: String = "abc"   // Non-nullable by default
// a = null             // Compilation error

var b: String? = "abc"  // Explicitly nullable type
b = null                // OK
        

Advanced Usage Examples:

// Smart casts
fun calculateLength(text: String?): Int {
    // Compiler tracks null checks
    if (text != null) {
        // Smart cast to non-nullable String within this scope
        return text.length // No need for safe call here
    }
    return 0
}

// Safe casts
val nullableAny: Any? = "String value"
val nullableString: String? = nullableAny as? String

// Collection filtering for non-null values
val nullableList: List<String?> = listOf("A", null, "B")
val nonNullValues: List<String> = nullableList.filterNotNull()

// Let with safe call for scoped operations
nullableString?.let { nonNullString ->
    // This code block executes only if nullableString is not null
    println("Length: ${nonNullString.length}")
}
        

// Non-nullable String - Compiled with @NotNull annotation
var required: String = "Value"

// Nullable String - Compiled with @Nullable annotation
var optional: String? = "Value" 

// Type hierarchy implications - a nullable type is not a subtype of its non-nullable version
fun nonNullParameter(s: String) { /* ... */ }
fun nullableParameter(s: String?) { /* ... */ }

val nonNull: String = "value"
val nullable: String? = "value"

nonNullParameter(nonNull)    // OK
nonNullParameter(nullable)   // Compilation error
nullableParameter(nonNull)   // OK (widening conversion)
nullableParameter(nullable)  // OK
        

// This code:
val length = str?.length

// Roughly compiles to:
val length = if (str != null) str.length else null

// Can be chained for nested safe navigation
user?.department?.head?.name  // Null if any step is null
        

// Basic usage for default values
val length = str?.length ?: 0

// Early returns from functions
fun getLength(str: String?): Int {
    // If str is null, returns -1 and exits the function
    val nonNullStr = str ?: return -1
    return nonNullStr.length
}

// Throwing custom exceptions
val name = person.name ?: throw CustomException("Name required")

// With let for compound operations
val length = str?.length ?: run {
    logger.warn("String was null")
    calculateDefaultLength()
}
        

// This code:
val length = str!!.length

// Compiles roughly to:
val tmp = str
if (tmp == null) throw KotlinNullPointerException()
val length = tmp.length
        

// Safe cast returns null on failure instead of throwing ClassCastException
val string: String? = value as? String

// Smart casts work with nullability checks
fun demo(x: String?) {
    if (x != null) {
        // x is automatically cast to non-nullable String in this scope
        println("Length of '$x' is ${x.length}")
    }
}
        

Collection Operations with Nullability:

// Working with collections containing nullable items
val nullableItems: List<String?> = listOf("A", null, "B")

// Filter out nulls and get a List<String> (non-nullable)
val nonNullItems: List<String> = nullableItems.filterNotNull()

// Transforming collections with potential nulls
val lengths: List<Int> = nullableItems.mapNotNull { it?.length }
        

Scope Functions with Nullability:

// let with safe call for null-safe operations
nullable?.let { nonNullValue ->
    // This block only executes if nullable is not null
    // nonNullValue is non-nullable inside this scope
    processValue(nonNullValue)
}

// also with safe call for side effects
nullable?.also { logger.info("Processing value: $it") }
             ?.let { computeResult(it) }

// Multiple conditions with run/apply
val result = nullable?.takeIf { it.isValid() }
                    ?.run { transform() }
                    ?: defaultValue
        

Declaration Syntax:

data class User(
    val id: Long, 
    val name: String, 
    val email: String? = null  // Optional properties with defaults are supported
)
        

Decompiled Equivalent (Pseudocode):

// What the compiler essentially generates for a data class
class User {
    private final Long id;
    private final String name;
    private final String email;

    // Constructor
    public User(Long id, String name, String email) {
        this.id = id;
        this.name = name;
        this.email = email;
    }

    // Getters
    public Long getId() { return id; }
    public String getName() { return name; }
    public String getEmail() { return email; }

    // equals() method
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        User user = (User) o;
        return id.equals(user.id) && 
               name.equals(user.name) && 
               (email != null ? email.equals(user.email) : user.email == null);
    }

    // hashCode() method
    @Override
    public int hashCode() {
        int result = id.hashCode();
        result = 31 * result + name.hashCode();
        result = 31 * result + (email != null ? email.hashCode() : 0);
        return result;
    }

    // toString() method
    @Override
    public String toString() {
        return "User(id=" + id + ", name=" + name + ", email=" + email + ")";
    }

    // Component functions for destructuring
    public Long component1() { return id; }
    public String component2() { return name; }
    public String component3() { return email; }

    // copy() function
    public User copy(Long id = this.id, String name = this.name, String email = this.email) {
        return new User(id, name, email);
    }
}
        

copy() Function Implementation:

The copy() function provides a powerful immutability pattern similar to the "wither pattern" in other languages:

data class User(
    val id: Long,
    val username: String,
    val email: String,
    val metadata: Map = emptyMap()
)

// The copy() function generates a specialized implementation that:
// 1. Performs a shallow copy
// 2. Allows named parameter overrides with defaults
// 3. Returns a new instance with original values for non-specified parameters

val user = User(1L, "jsmith", "john@example.com", 
    mapOf("lastLogin" to LocalDateTime.now()))

// Create derivative object while preserving immutability
val updatedUser = user.copy(email = "john.smith@example.com")

// Function signature generated is equivalent to:
// fun copy(
//    id: Long = this.id, 
//    username: String = this.username, 
//    email: String = this.email,
//    metadata: Map = this.metadata
// ): User
        

componentN() Functions:

These functions enable destructuring declarations via the destructuring convention:

data class NetworkResult(
    val data: ByteArray,
    val statusCode: Int,
    val headers: Map>,
    val latency: Duration
)

// Component functions are implemented as:
// fun component1(): ByteArray = this.data
// fun component2(): Int = this.statusCode
// fun component3(): Map> = this.headers
// fun component4(): Duration = this.latency

// Destructuring in practice:
fun processNetworkResponse(): NetworkResult {
    // Implementation omitted
    return NetworkResult(byteArrayOf(), 200, mapOf(), Duration.ZERO)
}

// Multiple return values with type safety
val (responseData, status, responseHeaders, _) = processNetworkResponse()

// Destructuring in lambda parameters
networkResults.filter { (_, status, _, _) -> status >= 400 }
              .map { (_, code, _, latency) -> 
                  ErrorMetric(code, latency.toMillis()) 
              }
        

Immutability with Complex Structures:

data class ImmutableState(
    val users: List,
    val selectedUserId: Long? = null,
    val isLoading: Boolean = false
)

// State transition function using copy
fun selectUser(state: ImmutableState, userId: Long): ImmutableState {
    return state.copy(selectedUserId = userId)
}

// Creating defensive copies for mutable collections
data class SafeState(
    // Using private backing field with public immutable interface
    private val _items: MutableList = mutableListOf()
) {
    // Expose as immutable
    val items: List get() = _items.toList()

    // Copy function needs special handling for mutable properties
    fun copy(items: List = this.items): SafeState {
        return SafeState(_items = items.toMutableList())
    }
}
        

Extension Function Definition and Compilation:

// Kotlin extension function
fun String.wordCount(): Int = this.split(Regex("\\s+")).count()

// Approximate Java equivalent after compilation
public static final int wordCount(String $receiver) {
    return $receiver.split("\\s+").length;
}
        

Extension Property with Custom Accessor:

val String.lastIndex: Int
    get() = length - 1

// With both accessors
var StringBuilder.lastChar: Char
    get() = get(length - 1)
    set(value) {
        setCharAt(length - 1, value)
    }
        

Resolution Example:

class Example {
    fun foo() = "Class method"
}

fun Example.foo() = "Extension function"

fun demo() {
    Example().foo() // Calls "Class method"
}
        

Nullable Receiver:

// Safe operations on nullable types
fun String?.isNullOrBlank(): Boolean = this == null || this.isBlank()

// Usage
val nullableString: String? = null
nullableString.isNullOrBlank() // true
        

Generic Extensions:

// Generic extension function
fun  List.secondOrNull(): T? = if (size >= 2) this[1] else null

// Constrained type parameters
fun > List.sorted(): List = 
    if (size <= 1) this else this.sorted()
        

inline fun  List.forEachIndexed(action: (Int, T) -> Unit) {
    for (index in indices) {
        action(index, this[index])
    }
}
        

Syntax Patterns:

// Basic extension function
fun Type.extensionFunction(params): ReturnType = body

// Extension function with receiver context
fun Type.extensionFunction() {
    // "this" refers to the receiver object (Type instance)
    this.existingMethod()
    this.existingProperty
    
    // "this" can be omitted
    existingMethod()
    existingProperty
}

// Extension property (must define accessors)
val Type.extensionProperty: PropertyType
    get() = computeValue()

// Mutable extension property
var Type.mutableProperty: PropertyType
    get() = computeValue()
    set(value) { processValue(value) }
        

1. Member vs Extension Resolution:

class MyClass {
    fun process() = "Member function"
}

fun MyClass.process() = "Extension function"

val instance = MyClass()
instance.process() // Calls "Member function" - members always win
        

2. Static Dispatch With Inheritance:

open class Base
class Derived : Base()

fun Base.extension() = "Base extension"
fun Derived.extension() = "Derived extension"

val derived = Derived()
val base: Base = derived

derived.extension() // Calls "Derived extension"
base.extension()    // Calls "Base extension" - static dispatch based on the declared type
        

1. Scope-specific Extensions:

// Extension only available within a class
class DateFormatter {
    // Only visible within DateFormatter
    private fun Date.formatForDisplay(): String {
        return SimpleDateFormat("yyyy-MM-dd").format(this)
    }
    
    fun formatDate(date: Date): String {
        return date.formatForDisplay() // Can use the extension here
    }
}
        

2. Extensions with Generics and Constraints:

// Generic extension with constraint
fun > List.sortedDescending(): List {
    return sortedWith(compareByDescending { it })
}

// Extension on platform types with nullable receiver
fun CharSequence?.isNullOrEmpty(): Boolean {
    return this == null || this.length == 0
}
        

3. Infix Extensions for DSL-like Syntax:

infix fun Int.timesRepeated(action: (Int) -> Unit) {
    for (i in 0 until this) action(i)
}

// Usage with infix notation
5 timesRepeated { println("Repetition: $it") }
        

1. Organizing Extensions:

// Recommended: Group related extensions in files named by convention
// StringExtensions.kt
package com.example.util

fun String.truncate(maxLength: Int): String {
    return if (length <= maxLength) this else substring(0, maxLength) + "..."
}

// Import extensions specifically where needed
import com.example.util.truncate

// Or import all extensions from a file
import com.example.util.*
        

2. Boundary Extensions for Clean Architecture:

// Domain model
data class User(val id: String, val name: String, val email: String)

// Database layer extension
fun User.toEntity() = UserEntity(id, name, email)

// API layer extension
fun User.toDto() = UserDto(id, name, email)
        

Inline Extensions:

// Inline higher-order extensions avoid lambda allocation overhead
inline fun  Iterable.firstOrDefault(predicate: (T) -> Boolean, defaultValue: T): T {
    for (element in this) if (predicate(element)) return element
    return defaultValue
}
        

Lambda Type Signatures and Syntax Variants:

// Full syntax with explicit types
val sum1: (Int, Int) -> Int = { a: Int, b: Int -> a + b }

// Type inference from context
val sum2 = { a: Int, b: Int -> a + b }

// Type inference for parameters from the variable type
val sum3: (Int, Int) -> Int = { a, b -> a + b }

// Single parameter shorthand using 'it'
val square: (Int) -> Int = { it * it }

// Lambda with receiver
val greeter: String.() -> String = { "Hello, $this" }
"World".greeter() // Returns "Hello, World"

// Trailing lambda syntax
fun performOperation(a: Int, b: Int, operation: (Int, Int) -> Int) = operation(a, b)
performOperation(5, 3) { a, b -> a * b } // Trailing lambda syntax
        

Function Type Declarations and Higher-Order Function Patterns:

// Function type as parameter
fun  Collection.customMap(transform: (T) -> R): List {
    val result = mutableListOf()
    for (item in this) {
        result.add(transform(item))
    }
    return result
}

// Function type with receiver
fun  T.customApply(block: T.() -> Unit): T {
    block()
    return this
}

// Function type as return value
fun  getValidator(predicate: (T) -> Boolean): (T) -> Boolean {
    return { value: T -> 
        println("Validating $value")
        predicate(value)
    }
}

val isPositive = getValidator { it > 0 }
isPositive(5) // Logs "Validating 5" and returns true
        

Inline Functions and Performance:

// Standard higher-order function (creates function object)
fun standardOperation(a: Int, b: Int, op: (Int, Int) -> Int): Int = op(a, b)

// Inline higher-order function (no function object created)
inline fun inlinedOperation(a: Int, b: Int, op: (Int, Int) -> Int): Int = op(a, b)

// Non-local returns are possible with inline functions
inline fun processNumbers(numbers: List, processor: (Int) -> Unit) {
    for (number in numbers) {
        processor(number)
        // The lambda can use `return` to exit the calling function
    }
}

fun findFirstEven(numbers: List): Int? {
    var result: Int? = null
    processNumbers(numbers) { 
        if (it % 2 == 0) {
            result = it
            return@processNumbers // Without inline, this would be the only option
            // With inline, we could also write `return result` to exit findFirstEven
        }
    }
    return result
}
        

Advanced Higher-Order Function Usage:

// Chained operations with lazy evaluation
val result = listOf(1, 2, 3, 4, 5)
    .asSequence()  // Creates a lazy sequence
    .map { it * 2 }
    .filter { it > 5 }
    .take(2)
    .toList()  // [6, 8]

// fold for stateful accumulation
val sum = listOf(1, 2, 3, 4, 5).fold(0) { acc, value -> acc + value }

// flatMap for flattening nested collections
val nestedLists = listOf(listOf(1, 2), listOf(3, 4))
val flattened = nestedLists.flatMap { it }  // [1, 2, 3, 4]

// groupBy for categorizing elements
val grouped = listOf(1, 2, 3, 4, 5).groupBy { if (it % 2 == 0) "even" else "odd" }

// runCatching for exception handling within lambdas
val result = runCatching {
    // potentially throwing operation
    "123".toInt()
}.getOrElse { 
    // handle the exception
    0 
}
        

Simplified Implementation of Common Higher-Order Functions:

// map implementation
inline fun  Iterable.map(transform: (T) -> R): List {
    val destination = ArrayList(collectionSizeOrDefault(10))
    for (item in this) {
        destination.add(transform(item))
    }
    return destination
}

// filter implementation
inline fun  Iterable.filter(predicate: (T) -> Boolean): List {
    val destination = ArrayList()
    for (element in this) {
        if (predicate(element)) {
            destination.add(element)
        }
    }
    return destination
}

// reduce implementation
inline fun  Iterable.reduce(operation: (acc: S, T) -> S): S {
    val iterator = this.iterator()
    if (!iterator.hasNext()) throw UnsupportedOperationException("Empty collection can't be reduced.")
    
    var accumulator: S = iterator.next()
    while (iterator.hasNext()) {
        accumulator = operation(accumulator, iterator.next())
    }
    return accumulator
}
        

Lambda Syntax Variants and Their Compilation Strategy:

// Full syntax with explicit types
val lambda1: (Int, Int) -> Int = { x: Int, y: Int -> x + y }

// Type inference for lambda parameters
val lambda2: (Int, Int) -> Int = { x, y -> x + y }

// Type inference for the entire lambda expression
val lambda3 = { x: Int, y: Int -> x + y }

// Single parameter shorthand using 'it'
val lambda4: (Int) -> Int = { it * it }

// Lambda with receiver - "this" refers to the receiver object
val lambda5: String.() -> Int = { this.length }

// Function reference as alternative to lambda
val lambda6: (String) -> Int = String::length
        

Function Type Declarations and Variants:

// Basic function type
val func1: (Int, Int) -> Int

// Function type with nullable return
val func2: (Int, Int) -> Int?

// Nullable function type
val func3: ((Int, Int) -> Int)?

// Function type with receiver
val func4: Int.(Int) -> Int
// Usage: 5.func4(3) or func4(5, 3)

// Suspend function type (for coroutines)
val func5: suspend (Int) -> Int

// Generic function type
fun  transform(input: T, transformer: (T) -> R): R {
    return transformer(input)
}
        

// Simplified implementation of map
inline fun  Iterable.map(transform: (T) -> R): List {
    // Implementation optimizes collection size when possible
    val destination = ArrayList(collectionSizeOrDefault(10))
    for (item in this) {
        destination.add(transform(item))
    }
    return destination
}

// Performance variations
val list = (1..1_000_000).toList()

// Regular mapping - creates intermediate collection
val result1 = list.map { it * 2 }.filter { it % 3 == 0 }

// Sequence-based mapping - lazy evaluation, no intermediate collections
val result2 = list.asSequence().map { it * 2 }.filter { it % 3 == 0 }.toList()
        

// Simplified implementation of filter
inline fun  Iterable.filter(predicate: (T) -> Boolean): List {
    val destination = ArrayList()
    for (element in this) {
        if (predicate(element)) {
            destination.add(element)
        }
    }
    return destination
}

// Specialized variants 
val nullableList = listOf("one", null, "two", null)
val nonNullItems = nullableList.filterNotNull() // More efficient than filtering nulls

// filterIsInstance - both filters and casts in one operation
val mixedList = listOf("string", 1, 2.5, "another")
val numbers = mixedList.filterIsInstance() // [1, 2.5]
        

// reduce implementation
inline fun  Iterable.reduce(operation: (S, T) -> S): S {
    val iterator = this.iterator()
    if (!iterator.hasNext()) 
        throw UnsupportedOperationException("Empty collection can't be reduced.")
    
    var accumulator: S = iterator.next()
    while (iterator.hasNext()) {
        accumulator = operation(accumulator, iterator.next())
    }
    return accumulator
}

// fold implementation - with initial value
inline fun  Iterable.fold(initial: R, operation: (acc: R, T) -> R): R {
    var accumulator = initial
    for (element in this) {
        accumulator = operation(accumulator, element)
    }
    return accumulator
}

// Advanced usage with runningFold/runningReduce
val numbers = listOf(1, 2, 3, 4, 5)
val runningSum = numbers.runningFold(0) { acc, num -> acc + num }
// [0, 1, 3, 6, 10, 15] - sequence of partial results including initial value

val runningProduct = numbers.runningReduce { acc, num -> acc * num }
// [1, 2, 6, 24, 120] - sequence of partial results without initial value
        

Inline Functions and Lambda Performance:

// Non-inline higher-order function - creates object allocation
fun  regularMap(items: List, transform: (T) -> R): List {
    val result = mutableListOf()
    for (item in items) {
        result.add(transform(item))
    }
    return result
}

// Inline higher-order function - no object allocation
inline fun  inlinedMap(items: List, transform: (T) -> R): List {
    val result = mutableListOf()
    for (item in items) {
        result.add(transform(item))
    }
    return result
}

// Using inline leads to bytecode that directly includes the lambda body
// at each call site - avoiding function object creation and virtual calls
        

Specialized Collection Operations:

val people = listOf(
    Person("Alice", 29), 
    Person("Bob", 31),
    Person("Charlie", 29)
)

// groupBy - group items by a key selector
val byAge = people.groupBy { it.age }
// Map with keys 29, 31 and corresponding lists of people

// associateBy - create Map keyed by a selector
val byName = people.associateBy { it.name }
// Map with keys "Alice", "Bob", "Charlie" and corresponding Person objects

// partition - split into two lists based on predicate
val (adults, minors) = people.partition { it.age >= 18 }

// windowed - create sliding window views of a collection
val numbers = listOf(1, 2, 3, 4, 5)
val windows = numbers.windowed(size = 3, step = 1)
// [[1, 2, 3], [2, 3, 4], [3, 4, 5]]

// zip - combine two collections
val names = listOf("Alice", "Bob", "Charlie")
val ages = listOf(29, 31, 25)
val nameAgePairs = names.zip(ages) { name, age -> "$name: $age" }
// ["Alice: 29", "Bob: 31", "Charlie: 25"]
        

Function Composition:

// Using built-in function composition
val isOdd: (Int) -> Boolean = { it % 2 != 0 }
val isPositive: (Int) -> Boolean = { it > 0 }

// Compose predicates using extension functions
fun  ((T) -> Boolean).and(other: (T) -> Boolean): (T) -> Boolean {
    return { this(it) && other(it) }
}

val isPositiveOdd = isOdd.and(isPositive)
listOf(1, 2, -3, 4, 5).filter(isPositiveOdd) // [1, 5]

// Composing transformations
infix fun  ((A) -> B).then(crossinline f: (B) -> C): (A) -> C {
    return { a -> f(this(a)) }
}

val double: (Int) -> Int = { it * 2 }
val toString: (Int) -> String = { it.toString() }

val doubleAndStringify = double then toString
doubleAndStringify(5) // "10"
        

Building Domain-Specific Languages (DSLs):

// Simple DSL for building HTML using higher-order functions
class TagBuilder(private val name: String) {
    private val children = mutableListOf()
    private val attributes = mutableMapOf()
    
    fun attribute(name: String, value: String) {
        attributes[name] = value
    }
    
    fun text(content: String) {
        children.add(content)
    }
    
    fun tag(name: String, init: TagBuilder.() -> Unit) {
        val builder = TagBuilder(name)
        builder.init()
        children.add(builder.build())
    }
    
    fun build(): String {
        val attributeString = attributes.entries
            .joinToString(" ") { "${it.key}=\"${it.value}\"" }
        val openTag = if (attributeString.isEmpty()) "<$name>" else "<$name $attributeString>"
        val childrenString = children.joinToString("")
        return "$openTag$childrenString"
    }
}

fun html(init: TagBuilder.() -> Unit): String {
    val builder = TagBuilder("html")
    builder.init()
    return builder.build()
}

fun TagBuilder.head(init: TagBuilder.() -> Unit) = tag("head", init)
fun TagBuilder.body(init: TagBuilder.() -> Unit) = tag("body", init)
fun TagBuilder.div(init: TagBuilder.() -> Unit) = tag("div", init)
fun TagBuilder.h1(init: TagBuilder.() -> Unit) = tag("h1", init)

// Usage of the HTML DSL
val htmlContent = html {
    head {
        tag("title") { text("My Page") }
    }
    body {
        div {
            attribute("class", "container")
            h1 { text("Hello, World!") }
        }
    }
}
        

Collection Implementation Architecture:

// Kotlin's collection interfaces (simplified conceptual code)
interface Collection<out E> {
    val size: Int
    fun isEmpty(): Boolean
    fun contains(element: @UnsafeVariance E): Boolean
    // Other query methods...
}

interface MutableCollection<E> : Collection<E> {
    fun add(element: E): Boolean
    fun remove(element: E): Boolean
    // Other modification methods...
}
        

Functional Operations Implementation:

// Java 8+ Stream approach
List<Integer> evenSquares = numbers.stream()
    .filter(n -> n % 2 == 0)
    .map(n -> n * n)
    .collect(Collectors.toList());

// Kotlin Collection approach (eager evaluation)
val evenSquares = numbers.filter { it % 2 == 0 }.map { it * it }

// Kotlin Sequence approach (lazy evaluation)
val evenSquares = numbers.asSequence()
    .filter { it % 2 == 0 }
    .map { it * it }
    .toList()
        

Advanced Collection Usage:

// Destructuring with Map entries
for ((key, value) in mapOf("a" to 1, "b" to 2)) {
    println("$key -> $value")
}

// Collection grouping and transformation
val groupedByFirstLetter = listOf("apple", "banana", "avocado", "cherry")
    .groupBy { it.first() }
    .mapValues { (_, fruits) -> fruits.map { it.uppercase() } }

// Custom collection extension
inline fun <T, R> Collection<T>.foldWithIndex(
    initial: R, 
    operation: (index: Int, acc: R, T) -> R
): R {
    var accumulator = initial
    forEachIndexed { index, element ->
        accumulator = operation(index, accumulator, element)
    }
    return accumulator
}
        

The Interface Hierarchy:

// Simplified representation of Kotlin's collection interfaces
interface Collection<out E> {
    val size: Int
    fun isEmpty(): Boolean
    fun contains(element: @UnsafeVariance E): Boolean
    // Query methods only
}

interface MutableCollection<E> : Collection<E> {
    fun add(element: E): Boolean
    fun remove(element: E): Boolean
    fun clear()
    // Modification methods
}
        

Covariance in Action:

fun addItems(items: Collection<Any>) { /* ... */ }

val strings: List<String> = listOf("a", "b")
addItems(strings)  // Works fine because List<String> is a subtype of Collection<Any>

val mutableStrings: MutableList<String> = mutableListOf("a", "b")
// addItems(mutableStrings)  // This would also work, but is conceptually less safe
        

Advanced Transformations:

// mapNotNull - transformation with null filtering
val validNumbers = listOf("1", "abc", "3").mapNotNull { it.toIntOrNull() }
// Result: [1, 3]

// Associate with transform
val nameToAgeMapping = listOf("Alice", "Bob").associate { it to it.length }
// Result: {Alice=5, Bob=3}

// Windowed operations
val numbers = listOf(1, 2, 3, 4, 5)
val windows = numbers.windowed(size = 3, step = 1)
// Result: [[1, 2, 3], [2, 3, 4], [3, 4, 5]]

// Zip with transform
val names = listOf("Alice", "Bob")
val ages = listOf(30, 25)
val people = names.zip(ages) { name, age -> "$name, $age years" }
// Result: ["Alice, 30 years", "Bob, 25 years"]
        

Custom Aggregations:

// Custom fold with pairs
val letters = listOf("a", "b", "c")
val positions = letters.foldIndexed(mutableMapOf<String, Int>()) { idx, map, letter ->
    map.apply { put(letter, idx) }
}
// Result: {a=0, b=1, c=2}

// Running totals with scan
val numbers = listOf(1, 2, 3, 4)
val runningSums = numbers.scan(0) { acc, num -> acc + num }
// Result: [0, 1, 3, 6, 10]

// Frequency counter with groupingBy
val wordCounts = "the quick brown fox jumps over the lazy dog"
    .split(" ")
    .groupingBy { it }
    .eachCount()
// Result: {the=2, quick=1, brown=1, fox=1, jumps=1, over=1, lazy=1, dog=1}
        

Performance Optimization Examples:

// Standard approach - creates two intermediate lists
val result = listOf(1, 2, 3, 4, 5)
    .filter { it % 2 == 0 }
    .map { it * it }

// Sequence approach - lazy evaluation, single pass
val result = listOf(1, 2, 3, 4, 5)
    .asSequence()
    .filter { it % 2 == 0 }
    .map { it * it }
    .toList()

// In-place mutable operations
val numbers = mutableListOf(1, 2, 3, 4, 5)
numbers.removeAll { it % 2 == 1 }
numbers.replaceAll { it * it }

// Using filterTo and mapTo to avoid intermediate collections
val evens = mutableListOf<Int>()
val squares = listOf(1, 2, 3, 4, 5)
    .filterTo(evens) { it % 2 == 0 }
    .map { it * it }