Lambda va qamrov funksiyalari

fun main() {
    val kvadrat = { x: Int -> x * x }
    val qoshish = { a: Int, b: Int -> a + b }
    val salom = { println("Salom!") }

    println(kvadrat(9))
    println(qoshish(15, 27))
    salom()
}

fun main() {
    val kvadrat: (Int) -> Int = { it * it }
    val qoshish: (Int, Int) -> Int = { a, b -> a + b }
    val chiqar: (String) -> Unit = { println(">> $it") }
    val tasodifiy: () -> Int = { 42 }

    println(kvadrat(5))
    println(qoshish(2, 3))
    chiqar("matn")
    println(tasodifiy())
}

fun bajar(a: Int, b: Int, amal: (Int, Int) -> Int): Int = amal(a, b)

fun takrorla(marta: Int, ish: (Int) -> Unit) {
    for (i in 1..marta) ish(i)
}

fun main() {
    println(bajar(6, 7) { x, y -> x * y })
    println(bajar(6, 7) { x, y -> x + y })

    takrorla(3) { println("$it-qadam") }
}

fun kopaytiruvchi(son: Int): (Int) -> Int = { it * son }

fun tekshiruvchi(chegara: Int): (Int) -> Boolean = { it > chegara }

fun main() {
    val ikkilantir = kopaytiruvchi(2)
    val uchlantir = kopaytiruvchi(3)

    println(ikkilantir(10))
    println(uchlantir(10))

    val kattami = tekshiruvchi(50)
    println(listOf(20, 60, 45, 80).filter(kattami))
}

fun sanagichYasa(): () -> Int {
    var soni = 0
    return { soni++; soni }
}

fun main() {
    val sana = sanagichYasa()
    println(sana())
    println(sana())
    println(sana())

    val boshqa = sanagichYasa()
    println(boshqa())
}

fun juftmi(x: Int): Boolean = x % 2 == 0

fun main() {
    val sonlar = listOf(1, 2, 3, 4, 5, 6)

    println(sonlar.filter(::juftmi))
    println(sonlar.filter { juftmi(it) })

    val ismlar = listOf("malika", "aziza")
    println(ismlar.map(String::uppercase))
    println(ismlar.map(String::length))

    val chiqar: (String) -> Unit = ::println
    chiqar("havola orqali")
}

fun main() {
    val ism: String? = "Malika"

    ism?.let {
        println("Uzunlik: ${it.length}")
        println("Katta: ${it.uppercase()}")
    }

    val uzunlik = ism?.let { it.length * 2 } ?: 0
    println(uzunlik)

    val sonlar = listOf(1, 2, 3)
    println(sonlar.map { it * 2 }.let { "Natija: $it" })
}

class Sozlama {
    var til: String = "uz"
    var mavzu: String = "yorug'"
    var avtoSaqlash: Boolean = false

    override fun toString() = "$til/$mavzu/$avtoSaqlash"
}

fun main() {
    val s = Sozlama().apply {
        til = "en"
        mavzu = "tungi"
        avtoSaqlash = true
    }

    println(s)

    val royxat = mutableListOf<Int>().apply {
        add(1)
        add(2)
        add(3)
    }
    println(royxat)
}

fun main() {
    val natija = listOf(3, 1, 2)
        .also { println("Boshlang'ich: $it") }
        .sorted()
        .also { println("Saralangan: $it") }
        .map { it * 10 }
        .also { println("Ko'paytirilgan: $it") }

    println("Yakuniy: $natija")
}

class Hisob(val egasi: String, val qoldiq: Int)

fun main() {
    val h = Hisob("Husanboy", 500000)

    val tavsif = h.run {
        "$egasi: $qoldiq so'm"
    }
    println(tavsif)

    val natija = with(h) {
        val soliq = qoldiq / 100
        "Soliq: $soliq"
    }
    println(natija)

    val qiymat = run {
        val a = 10
        val b = 20
        a + b
    }
    println(qiymat)
}

inline fun olcha(nom: String, ish: () -> Unit) {
    val boshi = System.nanoTime()
    ish()
    val vaqt = System.nanoTime() - boshi
    println("$nom: ${vaqt > 0}")
}

fun main() {
    olcha("sikl") {
        var s = 0
        for (i in 1..1000) s += i
        println("Yig'indi: $s")
    }
}