Cookbook

// Creating immutable collections
val numbers = listOf(1, 2, 3, 4, 5)
val names = setOf("Alice", "Bob", "Charlie")
val ages = mapOf("Alice" to 30, "Bob" to 25, "Charlie" to 35)

// Transforming immutable collections (returns new collections)
val doubled = numbers.map { it * 2 }  // [2, 4, 6, 8, 10]
val filtered = numbers.filter { it > 3 }  // [4, 5]
val sorted = names.sorted()  // [Alice, Bob, Charlie]

// Combining collections
val combined = numbers + listOf(6, 7)  // [1, 2, 3, 4, 5, 6, 7]
val union = names + setOf("David")  // [Alice, Bob, Charlie, David]

// Converting mutable to immutable
val mutableList = mutableListOf(1, 2, 3)
mutableList.add(4)
val immutableCopy = mutableList.toList()  // Creates immutable copy

// Working with indices
val indexed = numbers.withIndex()  // Sequence of IndexedValue
indexed.forEach { (index, value) ->
    println("Index $index: $value")
}

// Safe parallel access example
import kotlin.concurrent.thread

fun processDataSafely(data: List<Int>) {
    val threads = (1..5).map { threadId ->
        thread {
            // Safe: read-only access, no race conditions
            data.forEach { value ->
                println("Thread $threadId processing $value")
            }
        }
    }
    threads.forEach { it.join() }
}

processDataSafely(numbers)

// Problem: Eager evaluation creates intermediate lists
val numbers = (1..1_000_000).toList()
val result1 = numbers
    .map { it * 2 }      // Creates intermediate list of 1M items
    .filter { it > 100 } // Creates another intermediate list
    .take(10)            // Finally takes 10 items
// Total: Processed 1M items twice, created 2M intermediate items

// Solution: Lazy evaluation with sequences
val result2 = (1..1_000_000).asSequence()
    .map { it * 2 }      // No intermediate collection
    .filter { it > 100 } // No intermediate collection
    .take(10)            // Stops after finding 10 items
    .toList()            // Materialize final result
// Total: Processed ~50 items total (stops early with take)

// Creating sequences
val sequenceFromRange = (1..10).asSequence()
val sequenceFromList = listOf(1, 2, 3, 4, 5).asSequence()
val generatedSequence = generateSequence(1) { it + 1 }  // Infinite sequence

// Infinite sequences (compute on demand)
val fibonacci = generateSequence(Pair(0, 1)) { (a, b) ->
    Pair(b, a + b)
}.map { it.first }

// First 10 Fibonacci numbers
val first10Fib = fibonacci.take(10).toList()
println(first10Fib)  // [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]

// Reading large files lazily
import java.io.File

fun processLargeFile(path: String) {
    File(path).useLines { lines ->
        lines  // Sequence of lines
            .filter { it.startsWith("ERROR") }
            .map { it.uppercase() }
            .take(100)  // Process only first 100 matches
            .forEach { println(it) }
    }
    // File closed automatically after useLines block
}

// Custom sequence with yield
fun numbersWithMessages(): Sequence<String> = sequence {
    yield("Starting")

    for (i in 1..5) {
        yield("Number: $i")
    }

    yield("Finished")
}

numbersWithMessages().forEach { println(it) }

// Performance comparison
import kotlin.system.measureTimeMillis

fun comparePerformance() {
    val range = 1..10_000_000

    // Eager evaluation (collections)
    val timeEager = measureTimeMillis {
        range.toList()
            .map { it * 2 }
            .filter { it > 100 }
            .take(10)
    }

    // Lazy evaluation (sequences)
    val timeLazy = measureTimeMillis {
        range.asSequence()
            .map { it * 2 }
            .filter { it > 100 }
            .take(10)
            .toList()
    }

    println("Eager: ${timeEager}ms")
    println("Lazy: ${timeLazy}ms")  // Significantly faster
}

// Binary Tree with sealed class
sealed class BinaryTree<out T> {
    object Empty : BinaryTree<Nothing>()

    data class Node<T>(
        val value: T,
        val left: BinaryTree<T> = Empty,
        val right: BinaryTree<T> = Empty
    ) : BinaryTree<T>()

    // Type-safe operations with exhaustive when
    fun <R> fold(
        onEmpty: () -> R,
        onNode: (T, R, R) -> R
    ): R = when (this) {
        is Empty -> onEmpty()
        is Node -> onNode(
            value,
            left.fold(onEmpty, onNode),
            right.fold(onEmpty, onNode)
        )
    }

    fun contains(element: @UnsafeVariance T): Boolean = when (this) {
        is Empty -> false
        is Node -> value == element ||
                   left.contains(element) ||
                   right.contains(element)
    }

    fun size(): Int = fold(
        onEmpty = { 0 },
        onNode = { _, leftSize, rightSize -> 1 + leftSize + rightSize }
    )
}

// Using the tree
val tree = BinaryTree.Node(
    value = 5,
    left = BinaryTree.Node(
        value = 3,
        left = BinaryTree.Node(1),
        right = BinaryTree.Node(4)
    ),
    right = BinaryTree.Node(
        value = 7,
        left = BinaryTree.Node(6),
        right = BinaryTree.Node(9)
    )
)

println(tree.contains(4))  // true
println(tree.contains(10)) // false
println(tree.size())       // 7

// Linked List with sealed class
sealed class LinkedList<out T> {
    object Nil : LinkedList<Nothing>()

    data class Cons<T>(
        val head: T,
        val tail: LinkedList<T>
    ) : LinkedList<T>()

    fun <R> fold(
        onNil: () -> R,
        onCons: (T, LinkedList<T>) -> R
    ): R = when (this) {
        is Nil -> onNil()
        is Cons -> onCons(head, tail)
    }

    fun length(): Int = fold(
        onNil = { 0 },
        onCons = { _, tail -> 1 + tail.length() }
    )

    fun reverse(): LinkedList<T> {
        tailrec fun go(current: LinkedList<T>, acc: LinkedList<T>): LinkedList<T> =
            when (current) {
                is Nil -> acc
                is Cons -> go(current.tail, Cons(current.head, acc))
            }
        return go(this, Nil)
    }
}

// Helper function to create lists
fun <T> linkedListOf(vararg elements: T): LinkedList<T> =
    elements.foldRight(LinkedList.Nil as LinkedList<T>) { element, acc ->
        LinkedList.Cons(element, acc)
    }

val list = linkedListOf(1, 2, 3, 4, 5)
println(list.length())  // 5

val reversed = list.reverse()
// Cons(5, Cons(4, Cons(3, Cons(2, Cons(1, Nil)))))

// Result Type (functional error handling)
sealed class Result<out T, out E> {
    data class Success<T>(val value: T) : Result<T, Nothing>()
    data class Failure<E>(val error: E) : Result<Nothing, E>()

    fun <R> map(transform: (T) -> R): Result<R, E> = when (this) {
        is Success -> Success(transform(value))
        is Failure -> this
    }

    fun <R> flatMap(transform: (T) -> Result<R, E>): Result<R, E> = when (this) {
        is Success -> transform(value)
        is Failure -> this
    }

    fun <F> mapError(transform: (E) -> F): Result<T, F> = when (this) {
        is Success -> this
        is Failure -> Failure(transform(error))
    }

    fun getOrElse(default: @UnsafeVariance T): T = when (this) {
        is Success -> value
        is Failure -> default
    }
}

// Using Result type
data class User(val id: Int, val name: String)
sealed class DatabaseError {
    object NotFound : DatabaseError()
    data class ConnectionError(val message: String) : DatabaseError()
}

fun findUser(id: Int): Result<User, DatabaseError> {
    return if (id > 0) {
        Result.Success(User(id, "User $id"))
    } else {
        Result.Failure(DatabaseError.NotFound)
    }
}

fun getUserEmail(user: User): Result<String, DatabaseError> {
    return Result.Success("${user.name.lowercase().replace(" ", ".")}@example.com")
}

// Chain operations with flatMap
val result: Result<String, DatabaseError> = findUser(42)
    .flatMap { user -> getUserEmail(user) }
    .map { email -> email.uppercase() }

when (result) {
    is Result.Success -> println("Email: ${result.value}")
    is Result.Failure -> when (result.error) {
        is DatabaseError.NotFound -> println("User not found")
        is DatabaseError.ConnectionError -> println("Connection error: ${result.error.message}")
    }
}

// JSON AST (Abstract Syntax Tree)
sealed class Json {
    data class JObject(val fields: Map<String, Json>) : Json()
    data class JArray(val elements: List<Json>) : Json()
    data class JString(val value: String) : Json()
    data class JNumber(val value: Double) : Json()
    data class JBoolean(val value: Boolean) : Json()
    object JNull : Json()

    fun stringify(): String = when (this) {
        is JObject -> fields.entries.joinToString(
            prefix = "{",
            postfix = "}",
            separator = ","
        ) { (key, value) ->
            "\"$key\":${value.stringify()}"
        }
        is JArray -> elements.joinToString(
            prefix = "[",
            postfix = "]",
            separator = ","
        ) { it.stringify() }
        is JString -> "\"$value\""
        is JNumber -> value.toString()
        is JBoolean -> value.toString()
        is JNull -> "null"
    }
}

// Using JSON AST
val json = Json.JObject(
    mapOf(
        "name" to Json.JString("Alice"),
        "age" to Json.JNumber(30.0),
        "active" to Json.JBoolean(true),
        "address" to Json.JObject(
            mapOf(
                "city" to Json.JString("Jakarta"),
                "country" to Json.JString("Indonesia")
            )
        ),
        "hobbies" to Json.JArray(
            listOf(
                Json.JString("reading"),
                Json.JString("coding")
            )
        )
    )
)

println(json.stringify())

// HTML DSL example
@DslMarker
annotation class HtmlTagMarker

@HtmlTagMarker
abstract class Tag(val name: String) {
    val children = mutableListOf<Tag>()
    val attributes = mutableMapOf<String, String>()

    protected fun <T : Tag> initTag(tag: T, init: T.() -> Unit): T {
        tag.init()
        children.add(tag)
        return tag
    }

    fun render(): String = buildString {
        append("<$name")
        attributes.forEach { (key, value) ->
            append(" $key=\"$value\"")
        }
        append(">")
        children.forEach { append(it.render()) }
        append("</$name>")
    }
}

class HTML : Tag("html") {
    fun head(init: Head.() -> Unit) = initTag(Head(), init)
    fun body(init: Body.() -> Unit) = initTag(Body(), init)
}

class Head : Tag("head") {
    fun title(init: Title.() -> Unit) = initTag(Title(), init)
}

class Title : Tag("title") {
    operator fun String.unaryPlus() {
        children.add(object : Tag("") {
            override fun render() = this@unaryPlus
        })
    }
}

class Body : Tag("body") {
    fun h1(init: H1.() -> Unit) = initTag(H1(), init)
    fun p(init: P.() -> Unit) = initTag(P(), init)
    fun div(init: Div.() -> Unit) = initTag(Div(), init)
}

class H1 : Tag("h1") {
    operator fun String.unaryPlus() {
        children.add(object : Tag("") {
            override fun render() = this@unaryPlus
        })
    }
}

class P : Tag("p") {
    operator fun String.unaryPlus() {
        children.add(object : Tag("") {
            override fun render() = this@unaryPlus
        })
    }
}

class Div : Tag("div") {
    fun p(init: P.() -> Unit) = initTag(P(), init)

    var id: String
        get() = attributes["id"] ?: ""
        set(value) { attributes["id"] = value }

    var cssClass: String
        get() = attributes["class"] ?: ""
        set(value) { attributes["class"] = value }
}

fun html(init: HTML.() -> Unit): HTML {
    val html = HTML()
    html.init()
    return html
}

// Using the HTML DSL
val page = html {
    head {
        title {
            +"My Page Title"
        }
    }
    body {
        h1 {
            +"Welcome to Kotlin DSL"
        }
        div {
            id = "content"
            cssClass = "container"
            p {
                +"This is a paragraph"
            }
            p {
                +"This is another paragraph"
            }
        }
    }
}

println(page.render())

// SQL DSL example
@DslMarker
annotation class SqlMarker

@SqlMarker
class SelectQuery {
    private val columns = mutableListOf<String>()
    private var tableName: String = ""
    private val whereClauses = mutableListOf<String>()
    private val orderByClauses = mutableListOf<String>()
    private var limitValue: Int? = null

    fun select(vararg cols: String) {
        columns.addAll(cols)
    }

    fun from(table: String) {
        tableName = table
    }

    fun where(clause: String) {
        whereClauses.add(clause)
    }

    fun orderBy(vararg cols: String) {
        orderByClauses.addAll(cols)
    }

    fun limit(value: Int) {
        limitValue = value
    }

    fun build(): String = buildString {
        append("SELECT ")
        append(if (columns.isEmpty()) "*" else columns.joinToString(", "))
        append(" FROM $tableName")

        if (whereClauses.isNotEmpty()) {
            append(" WHERE ")
            append(whereClauses.joinToString(" AND "))
        }

        if (orderByClauses.isNotEmpty()) {
            append(" ORDER BY ")
            append(orderByClauses.joinToString(", "))
        }

        limitValue?.let { append(" LIMIT $it") }
    }
}

fun query(init: SelectQuery.() -> Unit): String {
    val query = SelectQuery()
    query.init()
    return query.build()
}

// Using SQL DSL
val sql = query {
    select("id", "name", "email")
    from("users")
    where("age > 18")
    where("status = 'ACTIVE'")
    orderBy("name", "id")
    limit(10)
}

println(sql)
// SELECT id, name, email FROM users WHERE age > 18 AND status = 'ACTIVE' ORDER BY name, id LIMIT 10

// Configuration DSL
@DslMarker
annotation class ConfigMarker

@ConfigMarker
class ServerConfig {
    var host: String = "localhost"
    var port: Int = 8080
    var ssl: Boolean = false

    private val routes = mutableListOf<Route>()

    fun route(path: String, init: Route.() -> Unit) {
        val route = Route(path)
        route.init()
        routes.add(route)
    }

    fun getRoutes() = routes.toList()
}

@ConfigMarker
class Route(val path: String) {
    var method: String = "GET"
    var handler: (String) -> String = { "Default response" }
}

fun server(init: ServerConfig.() -> Unit): ServerConfig {
    val config = ServerConfig()
    config.init()
    return config
}

// Using configuration DSL
val appServer = server {
    host = "0.0.0.0"
    port = 9000
    ssl = true

    route("/users") {
        method = "GET"
        handler = { "Fetching users" }
    }

    route("/users/{id}") {
        method = "POST"
        handler = { id -> "Creating user $id" }
    }
}

println("Server: ${appServer.host}:${appServer.port}, SSL: ${appServer.ssl}")
appServer.getRoutes().forEach { route ->
    println("Route: ${route.method} ${route.path}")
}

// String templates (avoid concatenation)
val name = "Alice"
val age = 30

// ❌ Inefficient (creates multiple String objects)
val message1 = "Name: " + name + ", Age: " + age

// ✅ Efficient (string template)
val message2 = "Name: $name, Age: $age"

// ✅ Expression in template
val message3 = "Name: ${name.uppercase()}, Age: ${age + 5}"

// Multi-line strings with trimIndent
val sql = """
    SELECT id, name, email
    FROM users
    WHERE age > 18
      AND status = 'ACTIVE'
    ORDER BY name
""".trimIndent()

// Multi-line with custom margin
val html = """
    |<html>
    |  <body>
    |    <h1>Hello</h1>
    |  </body>
    |</html>
""".trimMargin()

// StringBuilder for loops (avoid concatenation in loops)
fun buildLargeString(items: List<String>): String {
    // ❌ Inefficient - creates new String each iteration
    var result = ""
    for (item in items) {
        result += item + ", "
    }
    return result

    // ✅ Efficient - use buildString
}

fun buildLargeStringEfficiently(items: List<String>): String = buildString {
    items.forEachIndexed { index, item ->
        append(item)
        if (index < items.lastIndex) append(", ")
    }
}

// String splitting and joining
val csv = "Alice,30,alice@example.com"
val parts = csv.split(",")  // List<String>
val (name2, age2, email) = parts  // Destructuring

// Join with separator
val joined = listOf("apple", "banana", "cherry").joinToString(
    separator = ", ",
    prefix = "[",
    postfix = "]"
)
println(joined)  // [apple, banana, cherry]

// Custom transform
val uppercased = listOf("alice", "bob").joinToString { it.uppercase() }
println(uppercased)  // ALICE, BOB

// Regular expressions
val emailPattern = Regex("""[\w.]+@[\w.]+\.\w+""")
val text = "Contact us at support@example.com or sales@example.com"

// Find all matches
val emails = emailPattern.findAll(text).map { it.value }.toList()
println(emails)  // [support@example.com, sales@example.com]

// Replace with regex
val sanitized = text.replace(Regex("""@[\w.]+"""), "@***.**")
println(sanitized)  // Contact us at support@***.** or sales@***.**

// Validation
val isValidEmail = emailPattern.matches("user@example.com")

// String padding and trimming
val code = "42"
val padded = code.padStart(5, '0')  // "00042"
val rightPad = code.padEnd(5, '0')  // "42000"

val dirty = "  hello world  "
val clean = dirty.trim()          // "hello world"
val leftClean = dirty.trimStart() // "hello world  "
val rightClean = dirty.trimEnd()  // "  hello world"

// Character operations
val sentence = "Hello World"
val firstChar = sentence.first()      // 'H'
val lastChar = sentence.last()        // 'd'
val chars = sentence.toCharArray()

val filtered = sentence.filter { it.isUpperCase() }  // "HW"
val mapped = sentence.map { it.uppercase() }  // List<String>
val mappedStr = sentence.map { it.uppercase() }.joinToString("")  // "HELLO WORLD"

// Substring operations
val url = "https://example.com/api/users/123"
val hasPrefix = url.startsWith("https://")  // true
val hasSuffix = url.endsWith("/123")        // true

val domain = url.substringAfter("://").substringBefore("/")  // "example.com"
val userId = url.substringAfterLast("/")  // "123"

// Remove prefix/suffix
val apiPath = url.removePrefix("https://example.com")  // "/api/users/123"
val cleanPath = apiPath.removeSuffix("/123")  // "/api/users"

// Case conversion
val original = "Hello World"
println(original.lowercase())     // "hello world"
println(original.uppercase())     // "HELLO WORLD"
println(original.capitalize())    // "Hello world"
println(original.decapitalize())  // "hello World"

// Title case (custom)
fun String.toTitleCase(): String = split(" ").joinToString(" ") {
    it.lowercase().replaceFirstChar { char -> char.uppercase() }
}
println("hello world".toTitleCase())  // "Hello World"

// String replacement
val text2 = "Hello World Hello Kotlin"
val replaced = text2.replace("Hello", "Hi")  // "Hi World Hi Kotlin"
val firstOnly = text2.replaceFirst("Hello", "Hi")  // "Hi World Hello Kotlin"

// Replace with transform
val numbers = "I have 2 apples and 3 oranges"
val doubled = numbers.replace(Regex("""\d+""")) { match ->
    (match.value.toInt() * 2).toString()
}
println(doubled)  // "I have 4 apples and 6 oranges"

// Checking string content
val number = "12345"
println(number.all { it.isDigit() })      // true
println(number.any { it.isLetter() })     // false
println(number.none { it.isLetter() })    // true

val mixed = "abc123"
println(mixed.all { it.isLetterOrDigit() })  // true

// Line operations
val multiLine = """
    Line 1
    Line 2
    Line 3
""".trimIndent()

val lines = multiLine.lines()  // List<String>
val nonEmpty = multiLine.lineSequence().filter { it.isNotBlank() }.toList()

// Chunking strings
val long = "ABCDEFGHIJK"
val chunked = long.chunked(3)  // ["ABC", "DEF", "GHI", "JK"]

// With transform
val chunkedUpper = long.chunked(3) { it.toString().lowercase() }
// ["abc", "def", "ghi", "jk"]

// Windowed (sliding window)
val windowed = "ABCDE".windowed(3)  // ["ABC", "BCD", "CDE"]
val step2 = "ABCDEF".windowed(3, step = 2)  // ["ABC", "CDE"]

// Common validation patterns
fun String.isValidEmail(): Boolean =
    Regex("""^[\w._%+-]+@[\w.-]+\.\w{2,}$""").matches(this)

fun String.isValidPhone(): Boolean =
    Regex("""^\+?[0-9]{10,15}$""").matches(this)

fun String.isValidUrl(): Boolean =
    Regex("""^https?://[\w.-]+\.\w{2,}(/.*)?$""").matches(this)

println("user@example.com".isValidEmail())  // true
println("+628123456789".isValidPhone())     // true
println("https://example.com".isValidUrl()) // true

import kotlinx.coroutines.*

// Basic launch (fire and forget)
fun basicLaunch() = runBlocking {
    launch {
        delay(1000)
        println("Task 1 completed")
    }

    launch {
        delay(500)
        println("Task 2 completed")
    }

    println("Main thread continues...")
}
// Output:
// Main thread continues...
// Task 2 completed (after 500ms)
// Task 1 completed (after 1000ms)

// Launch with explicit scope
suspend fun launchWithScope() = coroutineScope {
    val job1 = launch {
        repeat(5) { i ->
            delay(100)
            println("Job 1: $i")
        }
    }

    val job2 = launch {
        repeat(3) { i ->
            delay(200)
            println("Job 2: $i")
        }
    }

    // Wait for specific job
    job1.join()
    println("Job 1 finished")
}

// Async for results
suspend fun asyncWithResult(): Int = coroutineScope {
    val deferred1 = async {
        delay(1000)
        40
    }

    val deferred2 = async {
        delay(500)
        2
    }

    // Wait for both results
    val result = deferred1.await() + deferred2.await()
    result  // Returns 42
}

// Parallel API calls
data class User(val id: Int, val name: String)
data class Profile(val bio: String)
data class Posts(val count: Int)

suspend fun fetchUser(id: Int): User {
    delay(100)  // Simulate API call
    return User(id, "User $id")
}

suspend fun fetchProfile(userId: Int): Profile {
    delay(150)  // Simulate API call
    return Profile("Bio for user $userId")
}

suspend fun fetchPosts(userId: Int): Posts {
    delay(200)  // Simulate API call
    return Posts(10)
}

suspend fun getUserData(userId: Int): Triple<User, Profile, Posts> = coroutineScope {
    // All three calls run in parallel
    val userDeferred = async { fetchUser(userId) }
    val profileDeferred = async { fetchProfile(userId) }
    val postsDeferred = async { fetchPosts(userId) }

    // Wait for all results
    Triple(
        userDeferred.await(),
        profileDeferred.await(),
        postsDeferred.await()
    )
}
// Sequential: 100 + 150 + 200 = 450ms
// Parallel: max(100, 150, 200) = 200ms

// Launch vs Async comparison
fun launchVsAsync() = runBlocking {
    // launch: fire and forget, no result
    val job = launch {
        delay(1000)
        println("Launch completed")
    }
    // job.join()  // Can only wait, no result

    // async: returns Deferred<T>, has result
    val deferred = async {
        delay(1000)
        "Async result"
    }
    val result = deferred.await()  // Can get result
    println(result)
}

// Multiple async tasks with awaitAll
suspend fun processMultiple(ids: List<Int>): List<User> = coroutineScope {
    ids.map { id ->
        async { fetchUser(id) }
    }.awaitAll()  // Wait for all in parallel
}

// Structured concurrency example
suspend fun structuredConcurrency() = coroutineScope {
    launch {
        delay(500)
        println("Child 1")
    }

    launch {
        delay(1000)
        println("Child 2")
    }

    println("Parent started")
    // Parent waits for ALL children before completing
}

// Cancellation example
fun cancellationExample() = runBlocking {
    val job = launch {
        repeat(1000) { i ->
            if (!isActive) {
                println("Cancelled at $i")
                return@launch
            }
            delay(100)
            println("Working: $i")
        }
    }

    delay(350)
    job.cancel()  // Cancel after 3 iterations
    job.join()
    println("Job cancelled")
}

// Exception handling with launch
fun exceptionInLaunch() = runBlocking {
    val exceptionHandler = CoroutineExceptionHandler { _, exception ->
        println("Caught exception: ${exception.message}")
    }

    val job = launch(exceptionHandler) {
        throw RuntimeException("Something went wrong")
    }

    job.join()
}

// Exception handling with async
suspend fun exceptionInAsync() = coroutineScope {
    val deferred = async {
        delay(100)
        throw RuntimeException("Async failed")
    }

    try {
        deferred.await()  // Exception thrown here
    } catch (e: Exception) {
        println("Caught: ${e.message}")
    }
}

import kotlinx.coroutines.*

// Basic timeout
suspend fun <T> executeWithTimeout(timeoutMs: Long, block: suspend () -> T): T? =
    try {
        withTimeout(timeoutMs) {
            block()
        }
    } catch (e: TimeoutCancellationException) {
        println("Operation timed out after ${timeoutMs}ms")
        null
    }

// Usage
suspend fun fetchData(): String {
    delay(2000)
    return "Data"
}

val result = executeWithTimeout(1000) {
    fetchData()  // Will timeout
}

// Retry logic with exponential backoff
suspend fun <T> retryWithBackoff(
    times: Int = 3,
    initialDelay: Long = 100,
    maxDelay: Long = 1000,
    factor: Double = 2.0,
    block: suspend () -> T
): T {
    var currentDelay = initialDelay
    repeat(times - 1) { attempt ->
        try {
            return block()
        } catch (e: Exception) {
            println("Attempt ${attempt + 1} failed: ${e.message}")
        }
        delay(currentDelay)
        currentDelay = (currentDelay * factor).toLong().coerceAtMost(maxDelay)
    }
    return block()  // Last attempt throws exception if fails
}

// Retry with specific exceptions
suspend fun <T> retryOn(
    times: Int = 3,
    exceptionClass: Class<out Exception>,
    block: suspend () -> T
): T {
    repeat(times - 1) {
        try {
            return block()
        } catch (e: Exception) {
            if (!exceptionClass.isInstance(e)) throw e
            println("Retrying after ${e::class.simpleName}")
        }
    }
    return block()
}

// Combined timeout and retry
suspend fun <T> executeWithTimeoutAndRetry(
    timeoutMs: Long,
    retries: Int = 3,
    block: suspend () -> T
): T {
    return retryWithBackoff(times = retries) {
        withTimeout(timeoutMs) {
            block()
        }
    }
}

// Real-world example: HTTP request with retry
class NetworkException(message: String) : Exception(message)

suspend fun makeHttpRequest(url: String): String {
    // Simulate network call
    delay(500)
    if (Math.random() < 0.7) throw NetworkException("Network error")
    return "Response from $url"
}

suspend fun reliableHttpRequest(url: String): String {
    return retryWithBackoff(times = 5, initialDelay = 200) {
        withTimeout(3000) {
            makeHttpRequest(url)
        }
    }
}

// Conditional retry
suspend fun <T> retryIf(
    times: Int = 3,
    predicate: (Exception) -> Boolean,
    block: suspend () -> T
): T {
    repeat(times - 1) {
        try {
            return block()
        } catch (e: Exception) {
            if (!predicate(e)) throw e
            println("Retrying due to: ${e.message}")
            delay(1000)
        }
    }
    return block()
}

// Usage with custom condition
val result2 = retryIf(
    times = 3,
    predicate = { it is NetworkException }
) {
    makeHttpRequest("https://api.example.com")
}

import kotlinx.coroutines.*

// Parallel execution with async
suspend fun parallelTasks() = coroutineScope {
    val task1 = async { computeTask1() }
    val task2 = async { computeTask2() }
    val task3 = async { computeTask3() }

    val results = listOf(task1.await(), task2.await(), task3.await())
}

// awaitAll for multiple tasks
suspend fun batchProcess(ids: List<Int>) = coroutineScope {
    ids.map { id ->
        async { processItem(id) }
    }.awaitAll()
}

// Parallel map operation
suspend fun <T, R> List<T>.parallelMap(transform: suspend (T) -> R): List<R> =
    coroutineScope {
        map { async { transform(it) } }.awaitAll()
    }

// Usage
val numbers = (1..100).toList()
val doubled = numbers.parallelMap { it * 2 }

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*

// Basic Flow creation
fun simpleFlow(): Flow<Int> = flow {
    for (i in 1..5) {
        delay(100)
        emit(i)
    }
}

// Collecting flow
suspend fun collectFlow() {
    simpleFlow().collect { value ->
        println(value)
    }
}

// Flow operators
suspend fun flowOperators() {
    simpleFlow()
        .map { it * 2 }
        .filter { it > 4 }
        .collect { println(it) }
}

// StateFlow for state management
class Counter {
    private val _count = MutableStateFlow(0)
    val count: StateFlow<Int> = _count.asStateFlow()

    fun increment() {
        _count.value++
    }
}

// SharedFlow for events
class EventBus {
    private val _events = MutableSharedFlow<String>()
    val events: SharedFlow<String> = _events.asSharedFlow()

    suspend fun emit(event: String) {
        _events.emit(event)
    }
}

import kotlinx.coroutines.*
import kotlinx.coroutines.channels.*

// Basic channel
suspend fun basicChannel() = coroutineScope {
    val channel = Channel<Int>()

    launch {
        for (x in 1..5) {
            channel.send(x)
        }
        channel.close()
    }

    for (y in channel) {
        println(y)
    }
}

// Producer-consumer with multiple consumers
suspend fun producerConsumer() = coroutineScope {
    val channel = Channel<Int>()

    // Producer
    launch {
        repeat(10) {
            channel.send(it)
        }
        channel.close()
    }

    // Multiple consumers
    repeat(3) { id ->
        launch {
            for (value in channel) {
                println("Consumer $id: $value")
            }
        }
    }
}

// Buffered channel
suspend fun bufferedChannel() = coroutineScope {
    val channel = Channel<Int>(capacity = 5)

    launch {
        repeat(10) {
            channel.send(it)
            println("Sent $it")
        }
        channel.close()
    }

    delay(1000)
    for (value in channel) {
        println("Received $value")
    }
}