Working with Kotlin Fundamentals

val appName: String = "MyApp"
var userAge: Int = 25
userAge = 26 // Valid reassignment

val user: User? = getUser()
val email = user?.email // Returns null if user is null

val name = user?.name ?: "Anonymous"
println(name) // Prints "Anonymous" if user.name is null

user?.let {
    println("User name: ${it.name}")
    it.updateLastLogin()
}

val number = 42 // Inferred as Int
val text = "Hello" // Inferred as String
val isTrue = true // Inferred as Boolean

val number: Int = 42
val text: String = "Hello"
val isTrue: Boolean = true

val price = 100
val message = "Price is $$price" // Escaping the dollar sign
println(message) // Output: Price is $100

data class Product(val id: Int, val name: String, val price: Double)

val product1 = Product(1, "Laptop", 999.99)
val product2 = product1.copy(name = "Gaming Laptop", price = 1299.99)

println(product1) // Output: Product(id=1, name=Laptop, price=999.99)
println(product2) // Output: Product(id=1, name=Gaming Laptop, price=1299.99)

fun List<String>.joinToStringWithComma(): String {
    return this.joinToString(", ")
}

val fruits = listOf("apple", "banana", "cherry")
val result = fruits.joinToStringWithComma()
// Output: "apple, banana, cherry"

val String.isPalindrome: Boolean
    get() = this == this.reversed()

val text = "racecar"
println(text.isPalindrome) // true

val numbers = listOf(1, 2, 3, 4, 5)
val result = numbers
    .filter { it % 2 == 0 }
    .map { it * 2 }
    .fold(0) { acc, num -> acc + num }

println(result) // Output: 12

sealed class Result<T> {
    data class Success<T>(val data: T) : Result<T>()
    data class Error(val message: String) : Result<T>()
}

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

sealed interface NetworkState {
    data class Connected(val host: String) : NetworkState
    data class Disconnected(val reason: String) : NetworkState
}

fun handleNetworkState(state: NetworkState) {
    when (state) {
        is NetworkState.Connected -> println("Connected to $host")
        is NetworkState.Disconnected -> println("Disconnected: $reason")
    }
}

object Logger {
    fun log(message: String) {
        println("LOG: $message")
    }
}

Logger.log("Application started") // Output: LOG: Application started

class Person {
    companion object {
        const val DEFAULT_AGE = 18
        fun createWithDefaultAge(): Person {
            return Person(DEFAULT_AGE)
        }
    }

    constructor(age: Int) {
        this.age = age
    }

    private var age: Int
}

val person = Person.createWithDefaultAge()
println(person.age) // Output: 18

inline fun<T> repeat(times: Int, body: (Int) -> T): List<T> {
    val result = mutableListOf<T>()
    for (i in 0 until times) {
        result.add(body(i))
    }
    return result
}

val numbers = repeat(3) { i -> i * 2 }
println(numbers) // [0, 2, 4]

inline fun processWithCallback(
    data: String,
    noinline callback: (String) -> Unit
) {
    println("Processing: $data")
    callback(data.uppercase())
}

processWithCallback("hello") { result ->
    println("Result: $result")
}

inline fun withReturn(
    crossinline block: () -> Unit
) {
    block()
}

fun main() {
    withReturn {
        return@withReturn // This is allowed due to crossinline
    }
}

typealias MapOfStrings = Map<String, String>

fun processMap(map: MapOfStrings) {
    map.forEach { (key, value) -> println("$key: $value") }
}

typealias UserMap = Map<String, List<User>>

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

fun processUsers(users: UserMap) {
    users.forEach { (key, userList) -> 
        println("Group: $key")
        userList.forEach { user -> println("  ${user.name}") }
    }
}