// Неявная типизация - компилятор выводит тип сам
val name = "John"           // String
val age = 25               // Int
val price = 19.99          // Double
val isActive = true        // Boolean

// Явная типизация - указываем тип явно
val name: String = "John"
val age: Int = 25
val price: Double = 19.99
val isActive: Boolean = true

var name: String = "John"        // Не может быть null
var nullable: String? = null     // Может быть null

// Безопасный вызов (?.) - вернет null если объект null
val length = nullable?.length

// Elvis-оператор (?:) - возвращает правое значение если левое null
val len = nullable?.length ?: 0

// Not-null assertion (!!) - принудительное приведение, может бросить NPE
val forcedLength = nullable!!.length

// let - выполняет блок кода если объект не null
nullable?.let { 
    println("Значение: $it")  // it - ссылка на объект
}

// run - выполняет блок кода в контексте объекта
val result = "Hello".run {
    this.uppercase()  // this - ссылка на объект
}

// also - выполняет действие с объектом, возвращает сам объект
val list = mutableListOf<String>().also {
    it.add("item1")
    it.add("item2")
}

// apply - конфигурирует объект, возвращает сам объект
val person = Person().apply {
    name = "John"
    age = 30
}

// Простое использование
val result = when (x) {
    1 -> "один"
    2, 3 -> "два или три"
    in 4..10 -> "от четырех до десяти"
    is String -> "это строка"
    else -> "что-то другое"
}

// Без аргумента - как цепочка if-else
val message = when {
    age < 18 -> "несовершеннолетний"
    age < 65 -> "взрослый"
    else -> "пенсионер"
}

val max = if (a > b) a else b
val status = if (score >= 60) "сдал" else "не сдал"

// For по диапазону
for (i in 1..5) print(i)        // 1, 2, 3, 4, 5
for (i in 1 until 5) print(i)   // 1, 2, 3, 4
for (i in 5 downTo 1) print(i)  // 5, 4, 3, 2, 1
for (i in 1..10 step 2) print(i) // 1, 3, 5, 7, 9

// For по коллекции
for (item in list) println(item)
for ((index, value) in list.withIndex()) {
    println("$index: $value")
}

// While остается классическим
while (condition) { /* код */ }
do { /* код */ } while (condition)

val range1 = 1..10           // IntRange от 1 до 10 включительно
val range2 = 1 until 10      // от 1 до 9 (10 не включается)
val range3 = 10 downTo 1     // от 10 до 1 по убыванию
val range4 = 1..10 step 2    // 1, 3, 5, 7, 9

// Проверка принадлежности
if (5 in 1..10) println("5 в диапазоне")

// Неизменяемые коллекции (read-only)
val list = listOf(1, 2, 3)
val set = setOf("a", "b", "c")
val map = mapOf("key1" to "value1", "key2" to "value2")

// Изменяемые коллекции (mutable)
val mutableList = mutableListOf(1, 2, 3)
val mutableSet = mutableSetOf("a", "b")
val mutableMap = mutableMapOf("key1" to "value1")

// Полезные операции
val filtered = list.filter { it > 1 }      // [2, 3]
val mapped = list.map { it * 2 }           // [2, 4, 6]
val sum = list.sum()                       // 6
val first = list.first()                   // 1
val last = list.last()                     // 3

// Деструктуризация пар и тройок
val pair = "John" to 25
val (name, age) = pair

// Деструктуризация data classes
data class Person(val name: String, val age: Int)
val person = Person("John", 25)
val (personName, personAge) = person

// В циклах
val map = mapOf("a" to 1, "b" to 2)
for ((key, value) in map) {
    println("$key = $value")
}

// Игнорирование значений с помощью _
val (name, _) = person  // возраст игнорируется

// is - проверка типа (аналог instanceof в Java)
if (obj is String) {
    println(obj.length)  // smart-cast к String
}

// !is - проверка на НЕ принадлежность типу
if (obj !is String) return

// as - небезопасное приведение типа
val str = obj as String

// as? - безопасное приведение, вернет null если не удается
val str = obj as? String

fun processValue(value: Any) {
    if (value is String) {
        // После проверки is, value автоматически имеет тип String
        println(value.length)        // не нужно явное приведение
        println(value.uppercase())
    }
    
    if (value is Int && value > 0) {
        // Smart-cast работает с логическими операторами
        println(value * 2)
    }
}

// Smart-cast с nullable типами
fun processNullable(str: String?) {
    if (str != null) {
        // После проверки на null, str имеет тип String
        println(str.length)
    }
}

data class User(val id: Long, val name: String, val email: String)

val user = User(1, "John", "john@example.com")
println(user) // User(id=1, name=John, email=john@example.com)

// copy() - создает копию с измененными полями
val updated = user.copy(email = "new@example.com")

// Деструктуризация через componentN()
val (id, name, email) = user

sealed class Result<T>
data class Success<T>(val data: T) : Result<T>()
data class Error<T>(val message: String) : Result<T>()
object Loading : Result<Nothing>()

// Компилятор знает все возможные типы - не нужен else
fun handleResult(result: Result<String>) = when (result) {
    is Success -> println(result.data)
    is Error -> println(result.message)
    is Loading -> println("Loading...")
}

enum class Priority(val level: Int) {
    LOW(1),
    MEDIUM(5),
    HIGH(10);
    
    fun isUrgent() = level > 7
}

// Встроенные методы
Priority.valueOf("HIGH")  // Получить по имени
Priority.values()         // Все значения
Priority.HIGH.ordinal     // Порядковый номер

// Singleton объект
object DatabaseConfig {
    val url = "jdbc:postgresql://localhost/db"
    fun connect() = println("Connecting to $url")
}

// Object expression - анонимный объект
val clickListener = object : MouseAdapter() {
    override fun mouseClicked(e: MouseEvent) {
        println("Clicked!")
    }
}

// Companion object - аналог static в Java
class MyClass {
    companion object Factory {
        fun create() = MyClass()
    }
}

class Person(val name: String, var age: Int) {
    // val/var в конструкторе автоматически создают свойства
}

// С модификаторами видимости
class User private constructor(val id: Long) {
    // Приватный конструктор
}

// Параметры без val/var - только для инициализации
class Calculator(initialValue: Int) {
    private val value = initialValue * 2
}

class Person(val name: String) {
    var age: Int = 0
    
    // Secondary constructor должен вызвать primary через this()
    constructor(name: String, age: Int) : this(name) {
        this.age = age
    }
    
    // Можно создать цепочку secondary конструкторов
    constructor(name: String, age: Int, email: String) : this(name, age) {
        // дополнительная инициализация
    }
}

class User(name: String, age: Int) {
    val name: String
    val age: Int
    
    init {
        require(age >= 0) { "Age must be non-negative" }
        this.name = name.trim()
        this.age = age
        println("User created: $name")
    }
    
    init {
        // Второй init блок - выполнится после первого
        println("Second init block")
    }
}

// open - разрешает наследование
open class Animal(val name: String) {
    open fun makeSound() = "Some sound"     // open - можно переопределить
    fun sleep() = "Sleeping"                // final - нельзя переопределить
}

class Dog(name: String) : Animal(name) {
    override fun makeSound() = "Woof!"      // override обязателен
    
    final override fun toString(): String {  // final override - запрещает дальнейшее переопределение
        return "Dog: $name"
    }
}

// Добавляем функцию к String
fun String.isValidEmail(): Boolean {
    return contains("@") && contains(".")
}

// Использование
val email = "user@example.com"
if (email.isValidEmail()) println("Valid email")

// Extension для generic типов
fun <T> List<T>.secondOrNull(): T? = if (size >= 2) this[1] else null

// Extension с nullable receiver
fun String?.isNullOrEmpty(): Boolean = this == null || this.isEmpty()

val String.lastChar: Char
    get() = this[length - 1]

var StringBuilder.lastChar: Char
    get() = this[length - 1]
    set(value) { setCharAt(length - 1, value) }

// Использование
println("Hello".lastChar)  // 'o'

inline fun <T> measureTime(block: () -> T): T {
    val start = System.currentTimeMillis()
    val result = block()
    val end = System.currentTimeMillis()
    println("Execution time: ${end - start}ms")
    return result
}

// Компилятор заменит вызов на встроенный код
val result = measureTime {
    // некоторые вычисления
    42
}

inline fun processData(
    data: List<String>,
    noinline logger: (String) -> Unit,  // не будет встроен
    processor: (String) -> String       // будет встроен
) {
    // logger можно передать в другую функцию
    data.forEach { logger(processor(it)) }
}

inline fun runSafely(crossinline action: () -> Unit) {
    try {
        action()  // не может содержать return из внешней функции
    } catch (e: Exception) {
        println("Error: ${e.message}")
    }
}

infix fun Int.times(str: String) = str.repeat(this)
infix fun String.shouldBe(expected: String) = assert(this == expected)

// Использование
val result = 3 times "Hello"  // вместо 3.times("Hello")
"actual" shouldBe "expected"  // вместо "actual".shouldBe("expected")

tailrec fun factorial(n: Long, accumulator: Long = 1): Long {
    return if (n <= 1) accumulator
    else factorial(n - 1, n * accumulator)  // хвостовой вызов
}

// Компилятор преобразует в цикл, избегая StackOverflowError
val result = factorial(10000)

// Read-only коллекции - интерфейсы без методов изменения
val readOnlyList: List<String> = listOf("a", "b", "c")
val readOnlySet: Set<Int> = setOf(1, 2, 3)
val readOnlyMap: Map<String, Int> = mapOf("key1" to 1, "key2" to 2)

// Mutable коллекции - расширяют read-only интерфейсы
val mutableList: MutableList<String> = mutableListOf("a", "b", "c")
val mutableSet: MutableSet<Int> = mutableSetOf(1, 2, 3)
val mutableMap: MutableMap<String, Int> = mutableMapOf("key1" to 1)

// Изменение возможно только у mutable
mutableList.add("d")
mutableSet.remove(1)
mutableMap["key3"] = 3

// Преобразование между типами
val readOnly = mutableListOf(1, 2, 3).toList()  // возвращает read-only view
val mutable = listOf(1, 2, 3).toMutableList()   // создает новую mutable коллекцию

// Read-only НЕ значит immutable - базовая коллекция может измениться
val original = mutableListOf(1, 2, 3)
val readOnlyView: List<Int> = original  // view на original
original.add(4)  // readOnlyView теперь содержит [1, 2, 3, 4]

// Создание
val fruits = listOf("apple", "banana", "apple")  // дубликаты разрешены
val mutableFruits = mutableListOf("orange", "grape")

// Основные операции
fruits[0]                    // "apple" - доступ по индексу
fruits.indexOf("apple")      // 0 - первое вхождение
fruits.lastIndexOf("apple")  // 2 - последнее вхождение
fruits.contains("banana")    // true

// Mutable операции
mutableFruits.add("kiwi")
mutableFruits.removeAt(0)
mutableFruits[0] = "mango"

val uniqueNumbers = setOf(1, 2, 3, 2, 1)  // результат: {1, 2, 3}
val mutableSet = mutableSetOf<String>()

// Операции с множествами
val set1 = setOf(1, 2, 3)
val set2 = setOf(3, 4, 5)

val union = set1 union set2         // {1, 2, 3, 4, 5}
val intersection = set1 intersect set2  // {3}
val difference = set1 subtract set2     // {1, 2}

// Проверки
set1.contains(2)     // true
2 in set1           // true (infix notation)

val ages = mapOf("John" to 25, "Jane" to 30)
val mutableAges = mutableMapOf<String, Int>()

// Доступ к значениям
ages["John"]        // 25 (nullable)
ages.getValue("John")  // 25 (бросает исключение если нет ключа)
ages.getOrDefault("Bob", 0)  // 0

// Операции
ages.keys           // {"John", "Jane"}
ages.values         // {25, 30}
ages.entries        // {Entry(John=25), Entry(Jane=30)}

// Mutable операции
mutableAges["Alice"] = 28
mutableAges.remove("John")
mutableAges.putAll(mapOf("Bob" to 35, "Carol" to 32))

// ArrayList (по умолчанию в listOf/mutableListOf)
val arrayList = mutableListOf(1, 2, 3)  // быстрый доступ по индексу O(1)

// LinkedList через Java
val linkedList = java.util.LinkedList<Int>()  // быстрая вставка/удаление O(1)

// Выбор зависит от паттерна использования:
// ArrayList: частый доступ по индексу
// LinkedList: частые вставки/удаления в середине

data class Person(val name: String, val age: Int, val city: String)

val people = listOf(
    Person("John", 25, "NYC"),
    Person("Jane", 30, "NYC"), 
    Person("Bob", 25, "LA")
)

// Группировка по возрасту
val byAge = people.groupBy { it.age }
// {25=[Person(John,25,NYC), Person(Bob,25,LA)], 30=[Person(Jane,30,NYC)]}

// Группировка с трансформацией значений
val namesByCity = people.groupBy({ it.city }, { it.name })
// {"NYC"=["John", "Jane"], "LA"=["Bob"]}

// Подсчет элементов в группах
val countByCity = people.groupingBy { it.city }.eachCount()
// {"NYC"=2, "LA"=1}

val people = listOf(
    Person("John", 25, "NYC"),
    Person("Jane", 30, "NYC"),
    Person("Bob", 25, "LA")
)

// Создание Map где ключ - имя, значение - объект Person
val peopleByName = people.associateBy { it.name }
// {"John"=Person(John,25,NYC), "Jane"=Person(Jane,30,NYC), "Bob"=Person(Bob,25,LA)}

// С трансформацией значения
val agesByName = people.associateBy({ it.name }, { it.age })
// {"John"=25, "Jane"=30, "Bob"=25}

// Associate - создание Map из пар
val cityToUppercase = people.associate { it.name to it.city.uppercase() }
// {"John"="NYC", "Jane"="NYC", "Bob"="LA"}

val numbers = listOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

// Разделение на четные и нечетные
val (evens, odds) = numbers.partition { it % 2 == 0 }
// evens = [2, 4, 6, 8, 10], odds = [1, 3, 5, 7, 9]

val people = listOf(
    Person("John", 17, "NYC"),
    Person("Jane", 25, "NYC"),
    Person("Bob", 30, "LA")
)

// Разделение по возрасту
val (adults, minors) = people.partition { it.age >= 18 }
// adults = [Person(Jane,25,NYC), Person(Bob,30,LA)]
// minors = [Person(John,17,NYC)]

val numbers = listOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

val result = numbers
    .map { println("Mapping $it"); it * it }      // выполнится для ВСЕХ элементов
    .filter { println("Filtering $it"); it > 10 } // создастся промежуточный список
    .take(3)                                      // возьмет первые 3

// Создается 3 промежуточные коллекции

val numbers = listOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

val result = numbers.asSequence()
    .map { println("Mapping $it"); it * it }      // НЕ выполнится сразу
    .filter { println("Filtering $it"); it > 10 } // НЕ выполнится сразу
    .take(3)                                      // НЕ выполнится сразу
    .toList()                                     // ЗДЕСЬ выполнятся все операции

// Обработает только необходимые элементы: 1,2,3,4 (до получения 3 результатов)

// Из коллекции
val sequence1 = listOf(1, 2, 3).asSequence()

// Генерирование
val sequence2 = generateSequence(1) { it + 1 }  // бесконечная последовательность
val sequence3 = sequenceOf(1, 2, 3, 4, 5)

// Sequence builder
val sequence4 = sequence {
    yield(1)
    yield(2)
    yieldAll(listOf(3, 4, 5))
}

// Используйте Sequence когда:

// 1. Большие коллекции с цепочками операций
val largeList = (1..1_000_000).toList()
val result = largeList.asSequence()
    .map { it * 2 }
    .filter { it > 100 }
    .take(10)
    .toList()

// 2. Потенциально бесконечные данные
val fibonacci = generateSequence(1 to 1) { (a, b) -> b to (a + b) }
    .map { it.first }
    .take(10)
    .toList()  // [1, 1, 2, 3, 5, 8, 13, 21, 34, 55]

// 3. Early termination (досрочное завершение)
val firstEven = (1..1000).asSequence()
    .map { heavyComputation(it) }  // выполнится только до первого четного
    .first { it % 2 == 0 }

val size = 1_000_000
val data = (1..size).toList()

// Iterable - создает промежуточные коллекции
val iterableResult = data
    .map { it * 2 }        // создает список из 1M элементов
    .filter { it > 100 }   // создает новый список
    .take(100)             // создает список из 100 элементов

// Sequence - обрабатывает элементы по одному
val sequenceResult = data.asSequence()
    .map { it * 2 }        // ленивая операция
    .filter { it > 100 }   // ленивая операция  
    .take(100)             // ленивая операция
    .toList()              // здесь выполняется вся цепочка для ~50 элементов

// Простая лямбда
val sum: (Int, Int) -> Int = { a, b -> a + b }

// Лямбда с одним параметром - можно использовать 'it'
val double: (Int) -> Int = { it * 2 }

// Лямбда без параметров
val greet: () -> String = { "Hello!" }

// Использование в функциях высшего порядка
listOf(1, 2, 3).map { it * 2 }  // [2, 4, 6]

// Анонимная функция
val multiply = fun(a: Int, b: Int): Int { return a * b }

// С выводом типа
val add = fun(a: Int, b: Int) = a + b

// В качестве параметра
listOf(1, 2, 3).filter(fun(x): Boolean { return x > 1 })

val numbers = listOf(1, 2, 3, 4)
val doubled = numbers.map { it * 2 }        // [2, 4, 6, 8]
val strings = numbers.map { "Number: $it" } // ["Number: 1", "Number: 2", ...]

// mapNotNull - исключает null значения
val mixed = listOf("1", "2", "abc", "4")
val parsed = mixed.mapNotNull { it.toIntOrNull() }  // [1, 2, 4]

val numbers = listOf(1, 2, 3, 4, 5, 6)
val evens = numbers.filter { it % 2 == 0 }     // [2, 4, 6]
val odds = numbers.filterNot { it % 2 == 0 }   // [1, 3, 5]

// filterIsInstance - фильтрует по типу
val mixed = listOf(1, "hello", 2, "world")
val strings = mixed.filterIsInstance<String>()  // ["hello", "world"]

val numbers = listOf(1, 2, 3, 4, 5)

// fold - с начальным значением
val sum = numbers.fold(0) { acc, element -> acc + element }  // 15
val product = numbers.fold(1) { acc, element -> acc * element }  // 120

// reduce - без начального значения
val sum2 = numbers.reduce { acc, element -> acc + element }  // 15
val max = numbers.reduce { acc, element -> if (acc > element) acc else element }  // 5

// foldRight/reduceRight - справа налево
val rightSum = numbers.foldRight(0) { element, acc -> element + acc }

val words = listOf("hello", "world")
val chars = words.flatMap { it.toList() }  // ['h', 'e', 'l', 'l', 'o', 'w', 'o', 'r', 'l', 'd']

val numbers = listOf(1, 2, 3)
val pairs = numbers.flatMap { n -> listOf(n, n * 2) }  // [1, 2, 2, 4, 3, 6]

// flatten - просто объединяет коллекции коллекций
val nested = listOf(listOf(1, 2), listOf(3, 4))
val flat = nested.flatten()  // [1, 2, 3, 4]

val person = Person("John", 25)
val result = with(person) {
    println("Name: $name")  // this.name
    println("Age: $age")    // this.age
    "Person processed"      // возвращаемое значение
}

val person = Person().apply {
    name = "John"    // this.name = "John"
    age = 25         // this.age = 25
    email = "john@example.com"
}
// person содержит настроенный объект

val result = person.run {
    validateAge()        // методы объекта
    "${name} is ${age}"  // возвращаемое значение
}

// Также как standalone функция
val result2 = run {
    val a = 10
    val b = 20
    a + b  // 30
}

val numbers = mutableListOf(1, 2, 3)
    .also { println("Original: $it") }  // it = [1, 2, 3]
    .also { it.add(4) }                 // добавляем элемент
    .also { println("Modified: $it") }  // it = [1, 2, 3, 4]

val name: String? = "John"
val result = name?.let { 
    println("Name is $it")  // it = "John"
    it.uppercase()          // возвращает "JOHN"
}

// Часто используется для цепочки вызовов
val result2 = listOf(1, 2, 3)
    .let { it.filter { n -> n > 1 } }  // [2, 3]
    .let { it.map { n -> n * 2 } }     // [4, 6]

data class User(val name: String?, val address: Address?)
data class Address(val street: String?, val city: String?)

val user: User? = getUser()

// Классическая проверка
val city = user?.address?.city

// С использованием let для обработки
val result = user?.let { user ->
    user.address?.let { address ->
        address.city?.let { city ->
            "User lives in $city"
        }
    }
}

// Более элегантно с run
val result2 = user?.run {
    address?.run {
        city?.let { "User lives in $it" }
    }
}

// Комбинирование с также
user?.also { println("Processing user: ${it.name}") }
    ?.address?.also { println("Address found") }
    ?.city?.let { println("City: $it") }

fun html(init: HTML.() -> Unit): HTML {
    val html = HTML()
    html.init()
    return html
}

class HTML {
    fun head(init: Head.() -> Unit) = Head().apply(init)
    fun body(init: Body.() -> Unit) = Body().apply(init)
}

class Head {
    fun title(text: String) = println("<title>$text</title>")
}

class Body {
    fun h1(text: String) = println("<h1>$text</h1>")
    fun p(text: String) = println("<p>$text</p>")
}

// Использование DSL
html {
    head {
        title("My Page")
    }
    body {
        h1("Welcome")
        p("This is a paragraph")
    }
}

class DatabaseConfig {
    var host: String = "localhost"
    var port: Int = 5432
    var username: String = ""
    var password: String = ""
}

fun database(init: DatabaseConfig.() -> Unit): DatabaseConfig {
    return DatabaseConfig().apply(init)
}

// Использование
val config = database {
    host = "production.db.com"
    port = 3306
    username = "admin"
    password = "secret"
}

// Инфиксная функция для DSL
infix fun String.shouldContain(substring: String) {
    assert(this.contains(substring)) { "$this should contain $substring" }
}

// Использование
"Hello World" shouldContain "World"

// Operator overloading для DSL
class SqlQuery {
    private val conditions = mutableListOf<String>()
    
    operator fun String.unaryPlus() {
        conditions.add(this)
    }
    
    fun build() = conditions.joinToString(" AND ")
}

fun query(init: SqlQuery.() -> Unit) = SqlQuery().apply(init)

// Использование
val sql = query {
    +"age > 18"
    +"status = 'active'"
}.build()  // "age > 18 AND status = 'active'"

// Простой generic класс
class Box<T>(val value: T) {
    fun get(): T = value
}

val stringBox = Box<String>("Hello")  // явное указание типа
val intBox = Box(42)                  // автовывод типа

// Множественные параметры типа
class Pair<A, B>(val first: A, val second: B)
val pair = Pair<String, Int>("key", 42)

// Generic функция с одним параметром типа
fun <T> singletonList(item: T): List<T> {
    return listOf(item)
}

val strings = singletonList("hello")  // List<String>
val numbers = singletonList(42)       // List<Int>

// Множественные параметры типа
fun <K, V> mapOf(key: K, value: V): Map<K, V> {
    return kotlin.collections.mapOf(key to value)
}

// Generic extension функция
fun <T> T.toSingletonList(): List<T> = listOf(this)

// Коваринтный интерфейс - только возвращает T
interface Producer<out T> {
    fun produce(): T                    // OK - возвращаем T
    // fun consume(item: T)             // ОШИБКА - нельзя принимать T
}

class StringProducer : Producer<String> {
    override fun produce(): String = "Hello"
}

// Коваринтность позволяет присваивать более специфический тип более общему
val stringProducer: Producer<String> = StringProducer()
val anyProducer: Producer<Any> = stringProducer  // OK: String <: Any

// Практический пример - List<out T> в Kotlin
val strings: List<String> = listOf("a", "b")
val anyList: List<Any> = strings  // OK, потому что List<out T>

// Контрвариантный интерфейс - только принимает T
interface Consumer<in T> {
    fun consume(item: T)               // OK - принимаем T
    // fun produce(): T                // ОШИБКА - нельзя возвращать T
}

class AnyConsumer : Consumer<Any> {
    override fun consume(item: Any) {
        println("Consuming: $item")
    }
}

// Контрвариантность позволяет присваивать более общий тип более специфическому
val anyConsumer: Consumer<Any> = AnyConsumer()
val stringConsumer: Consumer<String> = anyConsumer  // OK: Any >: String

// Практический пример - Comparable<in T>
class Person(val name: String) : Comparable<Person> {
    override fun compareTo(other: Person): Int = name.compareTo(other.name)
}

// Star projection для коваринтных типов
val unknownList: List<*> = listOf("a", "b", "c")  // эквивалент List<out Any?>
val item: Any? = unknownList.first()              // можем получить Any?
// unknownList.add("x")                           // ОШИБКА - нельзя добавлять

// Star projection для контрвариантных типов  
val unknownComparator: Comparator<*> = Comparator<String> { a, b -> a.compareTo(b) }
// unknownComparator.compare("a", "b")            // ОШИБКА - нельзя вызывать с аргументами

// Полезно для проверки типов без знания параметров
fun processList(list: List<*>) {
    println("List size: ${list.size}")
    // Можем работать с методами, не зависящими от типа элементов
}

// Producer - используйте out (extends в Java)
fun fillList(source: List<out Number>, destination: MutableList<Number>) {
    for (item in source) {
        destination.add(item)  // source может содержать Int, Double, etc.
    }
}

// Consumer - используйте in (super в Java)
fun copyTo(source: List<Number>, destination: MutableList<in Number>) {
    for (item in source) {
        destination.add(item)  // destination может принимать Number и его супертипы
    }
}

// Обычная функция - type erasure
fun <T> isOfType(value: Any): Boolean {
    // return value is T  // ОШИБКА - информация о T стерта
    return false
}

// Inline функция с reified - тип сохраняется
inline fun <reified T> isOfType(value: Any): Boolean {
    return value is T  // OK - информация о T доступна
}

// Использование
val result1 = isOfType<String>("hello")  // true
val result2 = isOfType<Int>("hello")     // false

// Создание объектов по типу
inline fun <reified T> createInstance(): T {
    return T::class.java.getDeclaredConstructor().newInstance()
}

// Фильтрация по типу
inline fun <reified T> List<*>.filterIsInstance(): List<T> {
    return this.filter { it is T }.map { it as T }
}

val mixed = listOf(1, "hello", 2, "world", 3.14)
val strings = mixed.filterIsInstance<String>()  // ["hello", "world"]

// JSON десериализация (популярный пример)
inline fun <reified T> fromJson(json: String): T {
    return Gson().fromJson(json, T::class.java)
}

val user = fromJson<User>("{\"name\":\"John\"}")

// Работает только с inline функциями
inline fun <reified T> validExample() { /* OK */ }

// НЕ работает с обычными функциями
// fun <reified T> invalidExample() { /* ОШИБКА */ }

// НЕ работает в свойствах классов
class Container<T> {
    // val type = T::class  // ОШИБКА - type erasure
}

// Ограничение одним супертипом
fun <T : Number> sumValues(values: List<T>): Double {
    return values.sumOf { it.toDouble() }  // toDouble() доступен через Number
}

val intSum = sumValues(listOf(1, 2, 3))        // OK - Int : Number
val doubleSum = sumValues(listOf(1.0, 2.0))    // OK - Double : Number
// val stringSum = sumValues(listOf("a", "b"))  // ОШИБКА - String !: Number

// Ограничение nullable типом
fun <T : Any> nonNullOnly(value: T): T {
    return value  // T гарантированно non-null
}

// Тип должен реализовывать и Comparable, и Serializable
fun <T> sortAndSerialize(items: List<T>): String 
    where T : Comparable<T>, 
          T : java.io.Serializable {
    val sorted = items.sorted()  // доступно через Comparable
    return sorted.toString()     // сериализация доступна
}

// Более сложный пример с множественными типами
fun <T, U> processData(data: T, processor: U): String
    where T : Collection<String>,
          T : Iterable<String>,
          U : Function<String, String> {
    return data.map { processor.apply(it) }.joinToString()
}

// Ограничения в объявлении класса
class SortedList<T : Comparable<T>> {
    private val items = mutableListOf<T>()
    
    fun add(item: T) {
        items.add(item)
        items.sort()  // sort() доступен через Comparable
    }
}

// Множественные ограничения в классах
class DataProcessor<T> where T : Readable, T : Closeable {
    fun process(resource: T) {
        try {
            val data = resource.read()  // доступно через Readable
            // обработка данных
        } finally {
            resource.close()  // доступно через Closeable
        }
    }
}

// Паттерн для builder'ов и fluent API
abstract class SelfReturning<SELF : SelfReturning<SELF>> {
    abstract fun self(): SELF
    
    fun commonMethod(): SELF {
        // общая логика
        return self()
    }
}

class ConcreteBuilder : SelfReturning<ConcreteBuilder>() {
    override fun self(): ConcreteBuilder = this
    
    fun specificMethod(): ConcreteBuilder {
        // специфичная логика
        return this
    }
}

// Использование - все методы возвращают правильный тип
val builder = ConcreteBuilder()
    .commonMethod()    // возвращает ConcreteBuilder
    .specificMethod()  // возвращает ConcreteBuilder

// Типы-маркеры для состояния
sealed class State
object Open : State()
object Closed : State()

class Connection<S : State> private constructor() {
    companion object {
        fun open(): Connection<Open> = Connection()
    }
    
    fun close(): Connection<Closed> = Connection()
    fun send(data: String): Connection<Open> = this  // только для открытых соединений
}

// Использование - компилятор проверяет состояние
val connection = Connection.open()
    .send("data")    // OK - соединение открыто
    .close()
    // .send("data") // ОШИБКА - соединение закрыто

// Проверка на null и преобразование
val result = name?.let { 
    println("Имя: $it")
    it.uppercase() // возвращается результат
}

// Цепочка вызовов
listOf(1, 2, 3)
    .let { it.filter { num -> num > 1 } }
    .let { println("Отфильтрованный список: $it") }

// Инициализация объекта
val person = Person().run {
    name = "Иван"
    age = 30
    this // можно опустить, вернётся автоматически
}

// Выполнение операций и возврат результата
val result = service.run {
    connect()
    fetchData()
    processData() // возвращается результат этого метода
}

// Работа с существующим объектом
val person = Person()
val result = with(person) {
    name = "Мария"
    age = 25
    getFullInfo() // возвращается результат
}

// Группировка операций
with(canvas) {
    drawLine(0, 0, 100, 100)
    drawCircle(50, 50, 25)
    save()
}

// Создание и настройка объекта
val person = Person().apply {
    name = "Пётр"
    age = 35
    email = "petr@example.com"
}

// Настройка View
val textView = TextView(context).apply {
    text = "Заголовок"
    textSize = 18f
    setTextColor(Color.BLACK)
}

// Логирование и дополнительные действия
val numbers = mutableListOf(1, 2, 3).also {
    println("Создан список: $it")
    log.info("Размер списка: ${it.size}")
}

// Цепочка с side effects
val result = processData()
    .also { println("Данные обработаны: $it") }
    .also { saveToCache(it) }
    .transform()

// Плохо
if (user != null) {
    println(user.name)
    saveUser(user)
}

// Хорошо
user?.let {
    println(it.name)
    saveUser(it)
}

// Создание конфигурации
val config = DatabaseConfig().apply {
    host = "localhost"
    port = 5432
    database = "myapp"
    username = "admin"
}

val result = inputData
    .let { validateInput(it) }
    .also { println("Валидация пройдена") }
    .let { processData(it) }
    .also { logResult(it) }
    .let { formatOutput(it) }

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

// Обработка HTTP ответов
fun handleResponse(result: Result<User>) = when (result) {
    is Result.Success -> showUser(result.data)
    is Result.Error -> showError(result.message)
    is Result.Loading -> showSpinner()
    // else не нужен — компилятор знает все варианты
}

// Состояния UI
sealed class UiState {
    object Idle : UiState()
    object Loading : UiState()
    data class Content(val items: List<String>) : UiState()
    data class Error(val throwable: Throwable) : UiState()
}

sealed interface ApiResponse
data class SuccessResponse(val data: String) : ApiResponse
data class ErrorResponse(val error: String) : ApiResponse

// Класс может реализовать несколько sealed interfaces
sealed interface Loadable
sealed interface Cacheable

data class DataState(val content: String) : ApiResponse, Loadable, Cacheable

// Архитектурные слои
sealed interface DomainEvent
data class UserLoggedIn(val userId: String) : DomainEvent
data class OrderCreated(val orderId: String) : DomainEvent

// Обработка событий
fun handleEvent(event: DomainEvent) = when (event) {
    is UserLoggedIn -> updateUserSession(event.userId)
    is OrderCreated -> sendNotification(event.orderId)
}

// Enum — только константы
enum class Status { SUCCESS, ERROR, LOADING }

// Sealed — с дополнительными данными
sealed class RequestState {
    object Loading : RequestState()
    data class Success(val data: Any) : RequestState()
    data class Failure(val exception: Throwable) : RequestState()
}

// Abstract — открытая иерархия
abstract class Shape {
    abstract fun area(): Double
}
// Кто угодно может наследоваться

// Sealed — закрытая иерархия
sealed class ValidationResult {
    object Valid : ValidationResult()
    data class Invalid(val errors: List<String>) : ValidationResult()
}
// Только объявленные наследники

sealed class Either<out L, out R> {
    data class Left<out L>(val value: L) : Either<L, Nothing>()
    data class Right<out R>(val value: R) : Either<Nothing, R>()
}

// Использование в функциональном стиле
fun divide(a: Int, b: Int): Either<String, Int> = 
    if (b == 0) Either.Left("Division by zero")
    else Either.Right(a / b)

sealed class ConnectionState {
    object Disconnected : ConnectionState()
    object Connecting : ConnectionState()
    data class Connected(val sessionId: String) : ConnectionState()
    data class Error(val reason: String) : ConnectionState()
}

class NetworkManager {
    fun transition(current: ConnectionState, event: Event): ConnectionState = 
        when (current to event) {
            ConnectionState.Disconnected to Event.Connect -> ConnectionState.Connecting
            ConnectionState.Connecting to Event.Success -> ConnectionState.Connected("session123")
            // ... другие переходы
            else -> current
        }
}

sealed interface DatabaseCommand {
    data class Insert(val entity: Entity) : DatabaseCommand
    data class Update(val id: String, val changes: Map<String, Any>) : DatabaseCommand
    data class Delete(val id: String) : DatabaseCommand
    data class Select(val query: Query) : DatabaseCommand
}

fun executeCommand(command: DatabaseCommand): DatabaseResult = when (command) {
    is DatabaseCommand.Insert -> repository.insert(command.entity)
    is DatabaseCommand.Update -> repository.update(command.id, command.changes)
    is DatabaseCommand.Delete -> repository.delete(command.id)
    is DatabaseCommand.Select -> repository.select(command.query)
}

sealed class ApiError {
    sealed class NetworkError : ApiError() {
        object NoConnection : NetworkError()
        object Timeout : NetworkError()
        data class HttpError(val code: Int) : NetworkError()
    }
    
    sealed class ParseError : ApiError() {
        object InvalidJson : ParseError()
        data class MissingField(val field: String) : ParseError()
    }
}

sealed class Validated<out T> {
    data class Valid<T>(val value: T) : Validated<T>()
    data class Invalid(val errors: NonEmptyList<ValidationError>) : Validated<Nothing>()
}

// Ограничение типов
sealed class Resource<out T : Any> {
    object Loading : Resource<Nothing>()
    data class Success<T : Any>(val data: T) : Resource<T>()
    data class Error(val exception: Throwable) : Resource<Nothing>()
}

// Компилятор требует обработки всех случаев
fun processState(state: UiState): String = when (state) {
    UiState.Idle -> "Ожидание"
    UiState.Loading -> "Загрузка"
    is UiState.Content -> "Контент: ${state.items.size} элементов"
    is UiState.Error -> "Ошибка: ${state.throwable.message}"
    // else НЕ нужен — sealed гарантирует полноту
}

// Состояния должны быть неизменяемыми
sealed class TaskState {
    object Pending : TaskState()
    data class InProgress(val progress: Int) : TaskState() // val, не var
    data class Completed(val result: String) : TaskState()
}

// Плохо
sealed class S { class A : S(); class B : S() }

// Хорошо
sealed class PaymentResult {
    data class Success(val transactionId: String) : PaymentResult()
    data class Declined(val reason: String) : PaymentResult()
    data class NetworkError(val cause: Throwable) : PaymentResult()
}