Kotlin: Null Safety, Data Classes, Coroutines and Flows Reference Guide

# Install via SDKMAN (recommended)
curl -s "https://get.sdkman.io" | bash
sdk install kotlin                  # JVM compiler + kotlin REPL
sdk install gradle

# Or via Homebrew
brew install kotlin gradle

# Run a single file
kotlin hello.kts                    # script (.kts)
kotlinc Hello.kt -include-runtime -d hello.jar && java -jar hello.jar

# New Gradle project (Kotlin DSL)
gradle init --type kotlin-application --dsl kotlin
./gradlew run

# Daily commands
./gradlew build                     # compile + test
./gradlew test --tests "MyTest"
./gradlew installDist               # build/install/bin/
./gradlew ktlintCheck detekt        # if you've added the plugins

// Data class — equals/hashCode/toString/copy auto-generated
data class User(
    val id: String,
    val name: String,
    val email: String? = null,        // nullable + default
)

// Sealed hierarchy — exhaustive when() with no else needed
sealed interface Result {
    data class Ok(val value: T) : Result
    data class Err(val message: String) : Result
}

// Enum with members
enum class Role(val label: String) {
    Admin("admin"), Member("member"), Guest("guest");

    val isPrivileged: Boolean get() = this == Admin
}

fun describe(r: Result): String = when (r) {
    is Result.Ok  -> "ok: ${r.value.name}"
    is Result.Err -> "failed: ${r.message}"
    // exhaustive — compiler verifies all variants are covered
}

fun main() {
    val u  = User("u1", "Ada")
    val u2 = u.copy(email = "ada@example.com")    // immutable update
    println(describe(Result.Ok(u2)))
    println(Role.Admin.isPrivileged)
}

// Scope function quick-reference
//   let     -> it,   returns lambda value     (transform, null-guard)
//   run     -> this, returns lambda value     (block-as-expression)
//   apply   -> this, returns receiver         (configure-and-return)
//   also    -> it,   returns receiver         (side-effects, logging)
//   with    -> this, returns lambda value     (group calls on a receiver)

data class Server(var host: String = "", var port: Int = 0, var tls: Boolean = false)

fun main() {
    // apply — configure-and-return
    val s = Server().apply {
        host = "api.devshelf.io"
        port = 443
        tls  = true
    }

    // also — side effects without breaking the chain
    val parsed = "42".toIntOrNull()
        ?.also { println("parsed: $it") }
        ?.let { it * 2 }
        ?: 0

    // run — block-as-expression on a receiver
    val description = s.run { "$host:$port${if (tls) " (tls)" else ""}" }

    // let — null guard + transform
    val email: String? = "ada@example.com"
    email?.let { println("send to: $it") }

    println("parsed=$parsed  desc=$description")
}

// build.gradle.kts:
// implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.8.0")
// implementation("io.ktor:ktor-client-core:2.3.10")
// implementation("io.ktor:ktor-client-cio:2.3.10")
// implementation("io.ktor:ktor-client-content-negotiation:2.3.10")
// implementation("io.ktor:ktor-serialization-kotlinx-json:2.3.10")

import io.ktor.client.*
import io.ktor.client.call.*
import io.ktor.client.engine.cio.*
import io.ktor.client.plugins.contentnegotiation.*
import io.ktor.client.request.*
import io.ktor.serialization.kotlinx.json.*
import kotlinx.coroutines.*
import kotlinx.serialization.Serializable

@Serializable
data class Repo(val name: String, val stargazers_count: Int)

suspend fun fetchRepos(client: HttpClient, owner: String): List =
    client.get("https://api.github.com/users/$owner/repos?per_page=5") {
        header("User-Agent", "devshelf")
    }.body()

fun main() = runBlocking {
    val client = HttpClient(CIO) {
        install(ContentNegotiation) { json() }
    }
    val owners = listOf("JetBrains", "Kotlin", "ktorio")

    // Concurrent fan-out via async/await
    val results = owners.map { owner ->
        async { runCatching { fetchRepos(client, owner) } }
    }.awaitAll()

    owners.zip(results).forEach { (owner, res) ->
        res.onSuccess { it.forEach { r -> println("$owner/${r.name} ★${r.stargazers_count}") } }
           .onFailure { System.err.println("$owner: ${it.message}") }
    }
    client.close()
}