The Ultimate Kotlin Cheatsheet

// ── Variables ──
val x: Int = 42              // immutable (preferred)
var y: String = "hello"       // mutable
val z = 3.14                   // type inference

// ── Basic Types ──
// Byte, Short, Int, Long, Float, Double, Boolean, Char, String
val i: Int = 42
val d: Double = 3.14
val s: String = "hello"
val b: Boolean = true
val c: Char = 'A'

// ── String Templates ──
val name = "World"
"Hello, $name"                 // "Hello, World"
"1 + 2 = ${1 + 2}"             // "1 + 2 = 3"

// ── Null Safety ──
var nullable: String? = null    // nullable type
val nonNull: String = "hello"   // non-null (compiler enforced)

// Safe call operator
val length = nullable?.length   // null if nullable is null

// Elvis operator (null coalescing)
val len = nullable?.length ?: 0 // default if null

// Not-null assertion (dangerous!)
val len2 = nullable!!.length    // NPE if null

// Safe cast
val str: String? = obj as? String  // null if not String

// Let block on nullable
nullable?.let {
    println("Value is $it, length ${it.length}")
}

// Lateinit (for DI)
lateinit var service: UserService
fun init() { service = UserService() }

// ── Type Checks ──
if (obj is String) {
    println(obj.length)    // smart cast (no cast needed)
}
if (obj !is String) { ... }

// ── Ranges ──
val range = 1..10           // 1 to 10 inclusive
val until = 1 until 10      // 1 to 9
val step = 1..10 step 2     // 1, 3, 5, 7, 9
val down = 10 downTo 1      // 10, 9, 8, ... 1

// ── Function Declaration ──
fun add(a: Int, b: Int): Int = a + b

fun greet(name: String, greeting: String = "Hello"): String {
    return "$greeting, $name!"
}

// Single-expression function
fun double(x: Int) = x * 2

// ── Unit return (void) ──
fun sayHello(): Unit {
    println("Hello!")
}

// ── Nothing return (never returns normally) ──
fun fail(message: String): Nothing {
    throw IllegalArgumentException(message)
}

// ── Extension Functions ──
fun String.addExclamation(): String = this + "!"
"hello".addExclamation()  // "hello!"

fun Int.isEven(): Boolean = this % 2 == 0
4.isEven()  // true

// ── Extension Properties ──
val String.firstChar: Char
    get() = this[0]

// ── Lambda Functions ──
val sum = { a: Int, b: Int -> a + b }
sum(3, 4)  // 7

val double: (Int) -> Int = { it * 2 }
double(5)  // 10

// Trailing lambda
val list = listOf(1, 2, 3, 4, 5)
list.filter { it > 3 }           // [4, 5]
list.map { it * 2 }              // [2, 4, 6, 8, 10]
list.find { it > 3 }             // 4
list.any { it > 3 }              // true
list.all { it > 0 }              // true
list.reduce { acc, n -> acc + n }  // 15
list.fold(0) { acc, n -> acc + n } // 15

// ── Infix Functions ──
infix fun Int.power(exp: Int): Long {
    return Math.pow(this.toDouble(), exp.toDouble()).toLong()
}
2 power 10  // 1024

// ── Inline Functions ──
inline fun measureTime(block: () -> Unit): Long {
    val start = System.currentTimeMillis()
    block()
    return System.currentTimeMillis() - start
}

val time = measureTime {
    // some work
}

// ── Class ──
class Person(val name: String, var age: Int) {
    var email: String = ""

    fun greet() = "Hi, I'm $name"

    // Companion object (static) 
    companion object {
        fun create(name: String) = Person(name, 0)
    }
}

// ── Data Class (like case class) ──
data class User(val name: String, val email: String, val age: Int = 0)

val u1 = User("Alice", "alice@example.com", 30)
val u2 = u1.copy(age = 31)          // non-destructive update
u1 == u2                          // structural equality (true)
u1 === u2                         // referential equality (false)

// Destructuring
val (name, email, age) = u1

// ── Sealed Class (restricted hierarchy) ──
sealed class Result<out T> {
    data class Success<T>(val data: T) : Result<T>()
    data class Error(val message: String) : Result<Nothing>()
    object Loading : Result<Nothing>()
}

fun process(result: Result<String>) = when (result) {
    is Result.Success -> println("Got: ${result.data}")
    is Result.Error -> println("Error: ${result.message}")
    Result.Loading -> println("Loading...")
}

// ── Enum ──
enum class Direction(val degrees: Int) {
    NORTH(0), EAST(90), SOUTH(180), WEST(270)
}

// ── Interface ──
interface Clickable {
    fun click()
    fun showOff() = println("I'm clickable!")
}

class Button : Clickable {
    override fun click() = println("Button clicked")
    override fun showOff() {
        super.showOff()
        println("I'm a button!")
    }
}

import kotlinx.coroutines.*

// ── Launch (fire and forget) ──
fun main() = runBlocking {
    launch {
        delay(1000)
        println("World!")
    }
    println("Hello,")
}

// ── Suspend Function ──
suspend fun fetchUser(id: Int): User {
    delay(500)  // simulated network call
    return User("Alice", "alice@example.com")
}

// ── Async (returns Deferred = Promise) ──
fun main() = runBlocking {
    val deferred: Deferred<User> = async { fetchUser(1) }
    val user = deferred.await()
    println(user.name)
}

// ── Parallel Execution ──
fun main() = runBlocking {
    val time = measureTimeMillis {
        val user = async { fetchUser(1) }
        val orders = async { fetchOrders(1) }
        println("User: ${user.await()}, Orders: ${orders.await().size}")
    }
}

// ── Dispatchers ──
launch(Dispatchers.IO) { /* I/O work */ }
launch(Dispatchers.Default) { /* CPU work */ }
launch(Dispatchers.Main) { /* UI thread */ }

// ── Structured Concurrency ──
suspend fun fetchAllData() = coroutineScope {
    val user = async { fetchUser(1) }
    val orders = async { fetchOrders(1) }
    try {
        Data(user.await(), orders.await())
    } catch (e: Exception) {
        user.cancel()
        throw e
    }
}

// ── Flow (cold stream) ──
fun countDown(): Flow<Int> = flow {
    for (i in 5 downTo 1) {
        emit(i)
        delay(1000)
    }
}

countDown().collect { value ->
    println(value)  // 5, 4, 3, 2, 1
}

// Flow operators
countDown()
    .filter { it > 2 }
    .map { "Number: $it" }
    .onEach { println(it) }
    .catch { e -> println("Error: ${e.message}") }
    .collect()

// ── Channels (hot stream) ──
val channel = Channel<Int>()
launch { for (x in channel) println(x) }
channel.send(1)
channel.send(2)
channel.close()

// ── List ──
val list = listOf(1, 2, 3)          // immutable
val mutable = mutableListOf(1, 2, 3) // mutable
mutable.add(4)
mutable.remove(1)
list + listOf(4, 5)                  // concat
list.reversed()
list.sorted()
list.sortedDescending()
list.distinct()
list.zip(listOf("a","b","c"))      // [(1,"a"), (2,"b"), (3,"c")]
list.flatten()
list.groupBy { if (it % 2 == 0) "even" else "odd" }

// ── Map ──
val map = mapOf("a" to 1, "b" to 2, "c" to 3)
val mutableMap = mutableMapOf("a" to 1)
mutableMap["d"] = 4
mutableMap.remove("a")
map.keys
map.values
map.entries
map.getOrDefault("z", 0)
map.filterKeys { it != "a" }
map.mapValues { it.value * 2 }
map.map { (k, v) -> v to k }        // swap

// ── Set ──
val set = setOf(1, 2, 3, 2, 1)     // {1, 2, 3}
val mutableSet = mutableSetOf(1, 2)
mutableSet.add(3)
mutableSet.contains(2)

// ── Sequence (lazy evaluation) ──
val seq = sequence {
    yield(1)
    yieldAll(2..10)
}
seq.take(5).toList()    // [1, 2, 3, 4, 5]

// ── Pair and Triple ──
val pair = "name" to "Alice"
val (key, value) = pair
val triple = Triple(1, "hello", true)
val (a, b, c) = triple