Generiklar

fun <T> ikkinchisi(royxat: List<T>): T? =
    if (royxat.size >= 2) royxat[1] else null

fun <T> juftlik(a: T, b: T): List<T> = listOf(a, b)

fun main() {
    println(ikkinchisi(listOf(10, 20, 30)))
    println(ikkinchisi(listOf("a", "b")))
    println(ikkinchisi(listOf(1.5)))
    println(juftlik("x", "y"))
}

class Quti<T> {
    private val elementlar = mutableListOf<T>()

    fun sol(element: T) {
        elementlar.add(element)
    }

    fun ol(indeks: Int): T = elementlar[indeks]

    val soni: Int get() = elementlar.size

    override fun toString() = elementlar.toString()
}

fun main() {
    val sonlar = Quti<Int>()
    sonlar.sol(10)
    sonlar.sol(20)
    println("$sonlar (${sonlar.soni} ta)")
    println(sonlar.ol(0) + 5)

    val ismlar = Quti<String>()
    ismlar.sol("Malika")
    println(ismlar.ol(0).uppercase())
}

fun <T : Comparable<T>> kattasi(a: T, b: T): T = if (a >= b) a else b

fun <T : Number> yigindi(royxat: List<T>): Double =
    royxat.sumOf { it.toDouble() }

fun main() {
    println(kattasi(15, 42))
    println(kattasi("olma", "anor"))
    println(kattasi(3.7, 2.1))

    println(yigindi(listOf(1, 2, 3)))
    println(yigindi(listOf(1.5, 2.5)))
}

interface Nomlangan {
    val nom: String
}

class Talaba(override val nom: String, val ball: Int) :
    Nomlangan, Comparable<Talaba> {
    override fun compareTo(other: Talaba) = ball.compareTo(other.ball)
}

fun <T> engYaxshi(royxat: List<T>): String
        where T : Nomlangan, T : Comparable<T> =
    royxat.max().nom

fun main() {
    val talabalar = listOf(
        Talaba("Malika", 88),
        Talaba("Aziza", 95),
        Talaba("Husanboy", 92)
    )
    println(engYaxshi(talabalar))
}

fun <T : Any> xavfsiz(qiymat: T): String = "Qiymat: $qiymat"

fun <T> ehtimol(qiymat: T): String = "Qiymat: $qiymat"

fun main() {
    println(xavfsiz("matn"))
    println(ehtimol("matn"))
    println(ehtimol(null))
}

open class Hayvon(val nom: String)
class It(nom: String) : Hayvon(nom)

fun hammasiniKorsat(hayvonlar: List<Hayvon>) {
    hayvonlar.forEach { println(it.nom) }
}

fun main() {
    val itlar: List<It> = listOf(It("Boryi"), It("Aqco"))
    hammasiniKorsat(itlar)
}

open class Hayvon(val nom: String)
class It(nom: String) : Hayvon(nom)

class Qafas<out T>(private val ichi: T) {
    fun ol(): T = ichi
}

fun main() {
    val itQafasi: Qafas<It> = Qafas(It("Boryi"))
    val hayvonQafasi: Qafas<Hayvon> = itQafasi

    println(hayvonQafasi.ol().nom)
}

open class Hayvon(val nom: String)
class It(nom: String) : Hayvon(nom)

class Boquvchi<in T> {
    fun boq(hayvon: T): String = "Boqildi"
}

fun main() {
    val hayvonBoquvchi: Boquvchi<Hayvon> = Boquvchi()
    val itBoquvchi: Boquvchi<It> = hayvonBoquvchi

    println(itBoquvchi.boq(It("Boryi")))
}

inline fun <reified T> faqatShular(royxat: List<Any>): List<T> =
    royxat.filterIsInstance<T>()

inline fun <reified T> turiMi(qiymat: Any): Boolean = qiymat is T

fun main() {
    val aralash = listOf(1, "matn", 2.5, "yana", 42, true)

    println(faqatShular<Int>(aralash))
    println(faqatShular<String>(aralash))

    println(turiMi<String>("salom"))
    println(turiMi<Int>("salom"))
}

fun olchami(royxat: List<*>): String =
    "Ro'yxatda ${royxat.size} element bor"

fun birinchisi(royxat: List<*>): Any? = royxat.firstOrNull()

fun main() {
    println(olchami(listOf(1, 2, 3)))
    println(olchami(listOf("a", "b")))
    println(birinchisi(listOf(10, 20)))
    println(birinchisi(emptyList<String>()))
}

class Natija<T> private constructor(
    private val qiymat: T?,
    private val xato: String?
) {
    companion object {
        fun <T> muvaffaqiyat(qiymat: T) = Natija(qiymat, null)
        fun <T> xato(xabar: String) = Natija<T>(null, xabar)
    }

    fun <R> ozgartir(amal: (T) -> R): Natija<R> =
        if (qiymat != null) muvaffaqiyat(amal(qiymat))
        else Natija(null, xato)

    override fun toString() =
        if (qiymat != null) "OK($qiymat)" else "XATO($xato)"
}

fun main() {
    val a = Natija.muvaffaqiyat(42)
    val b = Natija.xato<Int>("topilmadi")

    println(a)
    println(b)
    println(a.ozgartir { it * 2 })
    println(b.ozgartir { it * 2 })
    println(a.ozgartir { "Qiymat: $it" })
}